release: Bump version to 3.2.0-b3

Co-authored-by: Ayaz Salikhov <mathbunnyru@users.noreply.github.com>

.clang-tidy

@@ -1,4 +1,6 @@
 ---
+# This entire group of checks was applied to all cpp files but not all header files.
+# ---
 Checks: "-*,
   bugprone-argument-comment,
   bugprone-assert-side-effect,
@@ -8,26 +10,26 @@ Checks: "-*,
   bugprone-chained-comparison,
   bugprone-compare-pointer-to-member-virtual-function,
   bugprone-copy-constructor-init,
-  bugprone-crtp-constructor-accessibility,
+  # bugprone-crtp-constructor-accessibility, # has issues
   bugprone-dangling-handle,
   bugprone-dynamic-static-initializers,
-  bugprone-empty-catch,
+  # bugprone-empty-catch, # has issues
   bugprone-fold-init-type,
-  bugprone-forward-declaration-namespace,
-  bugprone-inaccurate-erase,
-  bugprone-inc-dec-in-conditions,
-  bugprone-incorrect-enable-if,
-  bugprone-incorrect-roundings,
-  bugprone-infinite-loop,
-  bugprone-integer-division,
+  # bugprone-forward-declaration-namespace, # has issues
+  # bugprone-inaccurate-erase,
+  # bugprone-inc-dec-in-conditions,
+  # bugprone-incorrect-enable-if,
+  # bugprone-incorrect-roundings,
+  # bugprone-infinite-loop,
+  # bugprone-integer-division,
   bugprone-lambda-function-name,
-  bugprone-macro-parentheses,
+  # bugprone-macro-parentheses, # has issues
   bugprone-macro-repeated-side-effects,
   bugprone-misplaced-operator-in-strlen-in-alloc,
   bugprone-misplaced-pointer-arithmetic-in-alloc,
   bugprone-misplaced-widening-cast,
   bugprone-move-forwarding-reference,
-  bugprone-multi-level-implicit-pointer-conversion,
+  # bugprone-multi-level-implicit-pointer-conversion, # has issues
   bugprone-multiple-new-in-one-expression,
   bugprone-multiple-statement-macro,
   bugprone-no-escape,
@@ -37,13 +39,13 @@ Checks: "-*,
   bugprone-pointer-arithmetic-on-polymorphic-object,
   bugprone-posix-return,
   bugprone-redundant-branch-condition,
-  bugprone-reserved-identifier,
-  bugprone-return-const-ref-from-parameter,
+  # bugprone-reserved-identifier, # has issues
+  # bugprone-return-const-ref-from-parameter, # has issues
   bugprone-shared-ptr-array-mismatch,
   bugprone-signal-handler,
   bugprone-signed-char-misuse,
   bugprone-sizeof-container,
-  bugprone-sizeof-expression,
+  # bugprone-sizeof-expression, # has issues
   bugprone-spuriously-wake-up-functions,
   bugprone-standalone-empty,
   bugprone-string-constructor,
@@ -60,7 +62,7 @@ Checks: "-*,
   bugprone-suspicious-string-compare,
   bugprone-suspicious-stringview-data-usage,
   bugprone-swapped-arguments,
-  bugprone-switch-missing-default-case,
+  # bugprone-switch-missing-default-case, # has issues
   bugprone-terminating-continue,
   bugprone-throw-keyword-missing,
   bugprone-too-small-loop-variable,
@@ -71,7 +73,7 @@ Checks: "-*,
   bugprone-unhandled-self-assignment,
   bugprone-unique-ptr-array-mismatch,
   bugprone-unsafe-functions,
-  bugprone-use-after-move,
+  # bugprone-use-after-move, # has issues
   bugprone-unused-raii,
   bugprone-unused-return-value,
   bugprone-unused-local-non-trivial-variable,
@@ -85,9 +87,11 @@ Checks: "-*,
   cppcoreguidelines-use-default-member-init,
   cppcoreguidelines-virtual-class-destructor,
   hicpp-ignored-remove-result,
+  misc-const-correctness,
   misc-definitions-in-headers,
   misc-header-include-cycle,
   misc-misplaced-const,
+  misc-redundant-expression,
   misc-static-assert,
   misc-throw-by-value-catch-by-reference,
   misc-unused-alias-decls,
@@ -95,46 +99,49 @@ Checks: "-*,
   modernize-deprecated-headers,
   modernize-make-shared,
   modernize-make-unique,
+  llvm-namespace-comment,
+  performance-faster-string-find,
+  performance-for-range-copy,
   performance-implicit-conversion-in-loop,
+  performance-inefficient-vector-operation,
+  performance-move-const-arg,
   performance-move-constructor-init,
+  performance-no-automatic-move,
   performance-trivially-destructible,
-  readability-avoid-nested-conditional-operator,
-  readability-avoid-return-with-void-value,
-  readability-braces-around-statements,
-  readability-const-return-type,
-  readability-container-contains,
-  readability-container-size-empty,
-  readability-convert-member-functions-to-static,
+  # readability-avoid-nested-conditional-operator, # has issues
+  # readability-avoid-return-with-void-value, # has issues
+  # readability-braces-around-statements, # has issues
+  # readability-const-return-type, # has issues
+  # readability-container-contains, # has issues
+  # readability-container-size-empty, # has issues
+  # readability-convert-member-functions-to-static, # has issues
   readability-duplicate-include,
-  readability-else-after-return,
-  readability-enum-initial-value,
-  readability-implicit-bool-conversion,
-  readability-make-member-function-const,
-  readability-math-missing-parentheses,
+  # readability-else-after-return, # has issues
+  # readability-enum-initial-value, # has issues
+  # readability-implicit-bool-conversion, # has issues
+  # readability-make-member-function-const, # has issues
+  # readability-math-missing-parentheses, # has issues
   readability-misleading-indentation,
   readability-non-const-parameter,
-  readability-redundant-casting,
-  readability-redundant-declaration,
-  readability-redundant-inline-specifier,
-  readability-redundant-member-init,
+  # readability-redundant-casting, # has issues
+  # readability-redundant-declaration, # has issues
+  # readability-redundant-inline-specifier, # has issues
+  # readability-redundant-member-init, # has issues
   readability-redundant-string-init,
   readability-reference-to-constructed-temporary,
-  readability-simplify-boolean-expr,
-  readability-static-definition-in-anonymous-namespace,
-  readability-suspicious-call-argument,
+  # readability-simplify-boolean-expr, # has issues
+  # readability-static-definition-in-anonymous-namespace, # has issues
+  # readability-suspicious-call-argument, # has issues
   readability-use-std-min-max
   "
 # ---
-# checks that have some issues that need to be resolved:
+# other checks that have issues that need to be resolved:
 #
-# llvm-namespace-comment,
-# misc-const-correctness,
 # misc-include-cleaner,
-# misc-redundant-expression,
 #
 # 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
-# readability-identifier-naming,
+# readability-identifier-naming,                       # https://github.com/XRPLF/rippled/pull/6571
 #
 # modernize-concat-nested-namespaces,
 # modernize-pass-by-value,
@@ -148,12 +155,6 @@ Checks: "-*,
 # modernize-use-starts-ends-with,
 # modernize-use-std-numbers,
 # modernize-use-using,
-#
-# performance-faster-string-find,
-# performance-for-range-copy,
-# performance-inefficient-vector-operation,
-# performance-move-const-arg,
-# performance-no-automatic-move,
 # ---
 #
 CheckOptions:
@@ -195,5 +196,6 @@ CheckOptions:
   bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
 #   misc-include-cleaner.IgnoreHeaders: '.*/(detail|impl)/.*;.*(expected|unexpected).*;.*ranges_lower_bound\.h;time.h;stdlib.h;__chrono/.*;fmt/chrono.h;boost/uuid/uuid_hash.hpp'
 #
-# HeaderFilterRegex: '^.*/(src|tests)/.*\.(h|hpp)$'
+HeaderFilterRegex: '^.*/(test|xrpl|xrpld)/.*\.(h|hpp)$'
+ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$'
 WarningsAsErrors: "*"

.github/scripts/levelization/results/ordering.txt

@@ -21,6 +21,7 @@ libxrpl.protocol > xrpl.json
 libxrpl.protocol > xrpl.protocol
 libxrpl.protocol_autogen > xrpl.protocol_autogen
 libxrpl.rdb > xrpl.basics
+libxrpl.rdb > xrpl.core
 libxrpl.rdb > xrpl.rdb
 libxrpl.resource > xrpl.basics
 libxrpl.resource > xrpl.json
@@ -90,6 +91,7 @@ test.core > xrpl.server
 test.csf > xrpl.basics
 test.csf > xrpld.consensus
 test.csf > xrpl.json
+test.csf > xrpl.ledger
 test.csf > xrpl.protocol
 test.json > test.jtx
 test.json > xrpl.json
@@ -108,7 +110,6 @@ test.jtx > xrpl.tx
 test.ledger > test.jtx
 test.ledger > test.toplevel
 test.ledger > xrpl.basics
-test.ledger > xrpld.app
 test.ledger > xrpld.core
 test.ledger > xrpl.ledger
 test.ledger > xrpl.protocol
@@ -125,6 +126,7 @@ test.overlay > xrpl.basics
 test.overlay > xrpld.app
 test.overlay > xrpld.overlay
 test.overlay > xrpld.peerfinder
+test.overlay > xrpl.ledger
 test.overlay > xrpl.nodestore
 test.overlay > xrpl.protocol
 test.overlay > xrpl.shamap
@@ -183,7 +185,6 @@ xrpl.conditions > xrpl.basics
 xrpl.conditions > xrpl.protocol
 xrpl.core > xrpl.basics
 xrpl.core > xrpl.json
-xrpl.core > xrpl.ledger
 xrpl.core > xrpl.protocol
 xrpl.json > xrpl.basics
 xrpl.ledger > xrpl.basics
@@ -234,6 +235,7 @@ xrpld.app > xrpl.shamap
 xrpld.app > xrpl.tx
 xrpld.consensus > xrpl.basics
 xrpld.consensus > xrpl.json
+xrpld.consensus > xrpl.ledger
 xrpld.consensus > xrpl.protocol
 xrpld.core > xrpl.basics
 xrpld.core > xrpl.core

.github/scripts/strategy-matrix/generate.py

@@ -235,16 +235,11 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
         # so that they are easier to identify in the GitHub Actions UI, as long
         # names get truncated.
         # Add Address and Thread (both coupled with UB) sanitizers for specific bookworm distros.
-        # Note: GCC ASAN's detect_stack_use_after_return produces false positives with
-        # Boost.Context fibers (boost::asio::spawn). Mitigated in reusable-build-test-config.yml
-        # by setting detect_stack_use_after_return=0 for GCC.
-        # See: https://github.com/google/sanitizers/issues/856
-        if os[
-            "distro_version"
-        ] == "bookworm" and f"{os['compiler_name']}-{os['compiler_version']}" in [
-            "gcc-13",
-            "clang-17",
-        ]:
+        # GCC-Asan rippled-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']}" == "clang-20"
+        ):
             # Add ASAN + UBSAN configuration.
             configurations.append(
                 {
@@ -258,19 +253,19 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
                     "sanitizers": "address,undefinedbehavior",
                 }
             )
-            # TSAN is activated on gcc-13 and clang-17.
-            activate_tsan = True
+            # TSAN is deactivated due to seg faults with latest compilers.
+            activate_tsan = False
             if activate_tsan:
                 configurations.append(
                     {
-                        "config_name": config_name + "-tsan",
+                        "config_name": config_name + "-tsan-ubsan",
                         "cmake_args": cmake_args,
                         "cmake_target": cmake_target,
                         "build_only": build_only,
                         "build_type": build_type,
                         "os": os,
                         "architecture": architecture,
-                        "sanitizers": "thread",
+                        "sanitizers": "thread,undefinedbehavior",
                     }
                 )
         else:

.github/workflows/check-pr-commits.yml

@@ -1,7 +1,7 @@
 name: Check PR commits
 
 on:
-  pull_request:
+  pull_request_target:
 
 # The action needs to have write permissions to post comments on the PR.
 permissions:

.github/workflows/conflicting-pr.yml

@@ -0,0 +1,25 @@
+name: Label PRs with merge conflicts
+
+on:
+  # So that PRs touching the same files as the push are updated.
+  push:
+  # So that the `dirtyLabel` is removed if conflicts are resolved.
+  # We recommend `pull_request_target` so that github secrets are available.
+  # In `pull_request` we wouldn't be able to change labels of fork PRs.
+  pull_request_target:
+    types: [synchronize]
+
+permissions:
+  pull-requests: write
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if PRs are dirty
+        uses: eps1lon/actions-label-merge-conflict@1df065ebe6e3310545d4f4c4e862e43bdca146f0 # v3.0.3
+        with:
+          dirtyLabel: "PR: has conflicts"
+          repoToken: "${{ secrets.GITHUB_TOKEN }}"
+          commentOnDirty: "This PR has conflicts, please resolve them in order for the PR to be reviewed."
+          commentOnClean: "All conflicts have been resolved. Assigned reviewers can now start or resume their review."

.github/workflows/publish-docs.yml

@@ -6,7 +6,6 @@ on:
   push:
     branches:
       - "develop"
-      - "release*"
     paths:
       - ".github/workflows/publish-docs.yml"
       - "*.md"
@@ -37,7 +36,7 @@ env:
   BUILD_DIR: build
   # ubuntu-latest has only 2 CPUs for private repositories
   # https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for--private-repositories
-  NPROC_SUBTRACT: ${{ github.event.repository.private && '1' || '2' }}
+  NPROC_SUBTRACT: ${{ github.event.repository.visibility == 'public' && '2' || '1' }}
 
 jobs:
   build:
@@ -82,13 +81,13 @@ jobs:
           cmake --build . --target docs --parallel ${BUILD_NPROC}
 
       - name: Create documentation artifact
-        if: ${{ github.event_name == 'push' }}
+        if: ${{ (github.repository_owner == 'XRPLF' || github.event.repository.visibility == 'public') && github.event_name == 'push' }}
         uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
         with:
           path: ${{ env.BUILD_DIR }}/docs/html
 
   deploy:
-    if: ${{ github.event_name == 'push' }}
+    if: ${{ (github.repository_owner == 'XRPLF' || github.event.repository.visibility == 'public') && github.event_name == 'push' }}
     needs: build
     runs-on: ubuntu-latest
     permissions:
@@ -100,4 +99,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deploy
-        uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5
+        uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0

.github/workflows/reusable-build-test-config.yml

@@ -199,7 +199,7 @@ jobs:
           fi
 
       - name: Upload the binary (Linux)
-        if: ${{ github.repository == 'XRPLF/rippled' && runner.os == 'Linux' }}
+        if: ${{ (github.repository_owner == 'XRPLF' || github.event.repository.visibility == 'public') && runner.os == 'Linux' }}
         uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: xrpld-${{ inputs.config_name }}
@@ -231,11 +231,8 @@ jobs:
           CONFIG_NAME: ${{ inputs.config_name }}
         run: |
           ASAN_OPTS="include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-asan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp"
-          # GCC ASAN's detect_stack_use_after_return produces false positives with
-          # Boost.Context fiber stack switching (used by boost::asio::spawn).
-          # See: https://github.com/google/sanitizers/issues/856
           if [[ "${CONFIG_NAME}" == *gcc* ]]; then
-            ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0:detect_stack_use_after_return=0"
+            ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
           fi
           echo "ASAN_OPTIONS=${ASAN_OPTS}" >> ${GITHUB_ENV}
           echo "TSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-tsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >> ${GITHUB_ENV}
@@ -245,11 +242,10 @@ jobs:
       - name: Run the separate tests
         if: ${{ !inputs.build_only }}
         working-directory: ${{ env.BUILD_DIR }}
-        # Windows locks some of the build files while running tests, and parallel jobs can collide.
-        # Sanitizer builds use single-threaded execution to reduce memory pressure.
+        # Windows locks some of the build files while running tests, and parallel jobs can collide
         env:
           BUILD_TYPE: ${{ inputs.build_type }}
-          PARALLELISM: ${{ env.SANITIZERS_ENABLED == 'true' && '1' || (runner.os == 'Windows' && '1' || steps.nproc.outputs.nproc) }}
+          PARALLELISM: ${{ runner.os == 'Windows' && '1' || steps.nproc.outputs.nproc }}
         run: |
           ctest \
             --output-on-failure \
@@ -260,21 +256,12 @@ jobs:
         if: ${{ !inputs.build_only }}
         working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
         env:
-          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
-          NPROC: ${{ steps.nproc.outputs.nproc }}
-          COVERAGE_ON: ${{ env.COVERAGE_ENABLED }}
-          SANITIZERS_ON: ${{ env.SANITIZERS_ENABLED }}
+          BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
         run: |
           set -o pipefail
-          if [ "${COVERAGE_ON}" = "true" ]; then
-            PARALLELISM=$(( NPROC > 2 ? NPROC - 2 : 1 ))
-          else
-            PARALLELISM="${NPROC}"
-          fi
-          if [ "${SANITIZERS_ON}" = "true" ]; then
-            PARALLELISM=1
-          fi
-          ./xrpld --unittest --unittest-jobs "${PARALLELISM}" 2>&1 | tee unittest.log
+          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
+          [ "$COVERAGE_ENABLED" = "true" ] && BUILD_NPROC=$(( BUILD_NPROC - 2 ))
+          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee unittest.log
 
       - name: Show test failure summary
         if: ${{ failure() && !inputs.build_only }}
@@ -311,7 +298,7 @@ jobs:
 
       - name: Upload coverage report
         if: ${{ github.repository == 'XRPLF/rippled' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
-        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
+        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
         with:
           disable_search: true
           disable_telem: true

.github/workflows/reusable-clang-tidy-files.yml

@@ -80,10 +80,10 @@ jobs:
         env:
           TARGETS: ${{ inputs.files != '' && inputs.files || 'src tests' }}
         run: |
-          run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" ${TARGETS} 2>&1 | tee clang-tidy-output.txt
+          run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" -quiet -allow-no-checks ${TARGETS} 2>&1 | tee clang-tidy-output.txt
 
       - name: Upload clang-tidy output
-        if: steps.run_clang_tidy.outcome != 'success'
+        if: ${{ (github.repository_owner == 'XRPLF' || github.event.repository.visibility == 'public') && steps.run_clang_tidy.outcome != 'success' }}
         uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: clang-tidy-results

.gitignore

@@ -71,6 +71,8 @@ DerivedData
 /.zed/
 
 # AI tools.
+/.agent
+/.agents
 /.augment
 /.claude
 /CLAUDE.md

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' 'nudb' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi')
+recipes=('abseil' 'ed25519' 'grpc' 'm4' 'mpt-crypto' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi')
 
 # Selectively check out the recipes from our CCI fork.
 cd external

BoostToStdCoroutineTaskList.md

@@ -1,142 +0,0 @@
-# Boost.Coroutine to C++20 Migration — Task List
-
-> Parent document: [BoostToStdCoroutineSwitchPlan.md](BoostToStdCoroutineSwitchPlan.md)
-
----
-
-## Milestone 1: New Coroutine Primitives
-
-- [ ] **1.1** Design `CoroTask<T>` class with `promise_type`
-  - Define `promise_type` with `initial_suspend`, `final_suspend`, `unhandled_exception`, `return_value`/`return_void`
-  - Implement `FinalAwaiter` for continuation support
-  - Implement move-only RAII handle wrapper
-  - Support both `CoroTask<T>` and `CoroTask<void>`
-
-- [ ] **1.2** Design and implement `JobQueueAwaiter`
-  - `await_suspend()` calls `jq_.addJob(type, name, [h]{ h.resume(); })`
-  - Handle `addJob()` failure (shutdown) — resume with error flag or throw
-  - Integrate `nSuspend_` counter increment/decrement
-
-- [ ] **1.3** Implement `LocalValues` swap in new coroutine resume path
-  - Before `handle.resume()`: save thread-local, install coroutine-local
-  - After `handle.resume()` returns: restore thread-local
-  - Ensure this works when coroutine migrates between threads
-
-- [ ] **1.4** Add `postCoroTask()` template to `JobQueue`
-  - Accept callable returning `CoroTask<void>`
-  - Schedule initial execution on JobQueue (mirror `postCoro()` behavior)
-  - Return a handle/shared_ptr for join/cancel
-
-- [ ] **1.5** Write unit tests (`src/test/core/CoroTask_test.cpp`)
-  - Test `CoroTask<void>` runs to completion
-  - Test `CoroTask<int>` returns value
-  - Test exception propagation across co_await
-  - Test coroutine destruction before completion
-  - Test `JobQueueAwaiter` schedules on correct thread
-  - Test `LocalValue` isolation across 4+ coroutines
-  - Test shutdown rejection (addJob returns false)
-  - Test `correct_order` equivalent (yield → join → post → complete)
-  - Test `incorrect_order` equivalent (post → yield → complete)
-  - Test multiple sequential co_await points
-
-- [ ] **1.6** Verify build on GCC 12+, Clang 16+
-- [ ] **1.7** Run ASAN + TSAN on new tests
-- [ ] **1.8** Run full `--unittest` suite (no regressions)
-- [ ] **1.9** Self-review and create PR #1
-
----
-
-## Milestone 2: Entry Point Migration
-
-- [ ] **2.1** Migrate `ServerHandler::onRequest()` (`ServerHandler.cpp:287`)
-  - Replace `m_jobQueue.postCoro(jtCLIENT_RPC, ...)` with `postCoroTask()`
-  - Update lambda to return `CoroTask<void>` (add `co_return`)
-  - Update `processSession` to accept new coroutine type
-
-- [ ] **2.2** Migrate `ServerHandler::onWSMessage()` (`ServerHandler.cpp:325`)
-  - Replace `m_jobQueue.postCoro(jtCLIENT_WEBSOCKET, ...)` with `postCoroTask()`
-  - Update lambda signature
-
-- [ ] **2.3** Migrate `GRPCServer::CallData::process()` (`GRPCServer.cpp:102`)
-  - Replace `app_.getJobQueue().postCoro(JobType::jtRPC, ...)` with `postCoroTask()`
-  - Update `process(shared_ptr<Coro> coro)` overload signature
-
-- [ ] **2.4** Update `RPC::Context` (`Context.h:27`)
-  - Replace `std::shared_ptr<JobQueue::Coro> coro{}` with new coroutine wrapper type
-  - Ensure all code that accesses `context.coro` compiles
-
-- [ ] **2.5** Update `ServerHandler.h` signatures
-  - `processSession()` and `processRequest()` parameter types
-
-- [ ] **2.6** Update `GRPCServer.h` signatures
-  - `process()` method parameter types
-
-- [ ] **2.7** Run full `--unittest` suite
-- [ ] **2.8** Manual smoke test: HTTP + WS + gRPC RPC requests
-- [ ] **2.9** Run ASAN + TSAN
-- [ ] **2.10** Self-review and create PR #2
-
----
-
-## Milestone 3: Handler Migration
-
-- [ ] **3.1** Migrate `doRipplePathFind()` (`RipplePathFind.cpp`)
-  - Replace `context.coro->yield()` with `co_await PathFindAwaiter{...}`
-  - Replace continuation lambda's `coro->post()` / `coro->resume()` with awaiter scheduling
-  - Handle shutdown case (post failure) in awaiter
-
-- [ ] **3.2** Create `PathFindAwaiter` (or use generic `JobQueueAwaiter`)
-  - Encapsulate the continuation + yield pattern from `RipplePathFind.cpp` lines 108-132
-
-- [ ] **3.3** Update `Path_test.cpp`
-  - Replace `postCoro` usage with `postCoroTask`
-  - Ensure `context.coro` usage matches new type
-
-- [ ] **3.4** Update `AMMTest.cpp`
-  - Replace `postCoro` usage with `postCoroTask`
-
-- [ ] **3.5** Rewrite `Coroutine_test.cpp` for new API
-  - `correct_order`: postCoroTask → co_await → join → resume → complete
-  - `incorrect_order`: post before yield equivalent
-  - `thread_specific_storage`: 4 coroutines with LocalValue isolation
-
-- [ ] **3.6** Update `JobQueue_test.cpp` `testPostCoro`
-  - Migrate to `postCoroTask` API
-
-- [ ] **3.7** Verify `ripple_path_find` works end-to-end with new coroutines
-- [ ] **3.8** Test shutdown-during-pathfind scenario
-- [ ] **3.9** Run full `--unittest` suite
-- [ ] **3.10** Run ASAN + TSAN
-- [ ] **3.11** Self-review and create PR #3
-
----
-
-## Milestone 4: Cleanup & Validation
-
-- [ ] **4.1** Delete `include/xrpl/core/Coro.ipp`
-- [ ] **4.2** Remove from `JobQueue.h`:
-  - `#include <boost/coroutine2/all.hpp>`
-  - `struct Coro_create_t`
-  - `class Coro` (entire class)
-  - `postCoro()` template
-  - Comment block (lines 322-377) describing old race condition
-- [ ] **4.3** Update `cmake/deps/Boost.cmake`:
-  - Remove `coroutine` from `find_package(Boost REQUIRED COMPONENTS ...)`
-  - Remove `Boost::coroutine` from `target_link_libraries`
-- [ ] **4.4** Update `cmake/XrplInterface.cmake`:
-  - Remove `BOOST_COROUTINES2_NO_DEPRECATION_WARNING`
-- [ ] **4.5** Run memory benchmark
-  - Create N=1000 coroutines, compare RSS: before vs after
-  - Document results
-- [ ] **4.6** Run context switch benchmark
-  - 100K yield/resume cycles, compare latency: before vs after
-  - Document results
-- [ ] **4.7** Run RPC throughput benchmark
-  - Concurrent `ripple_path_find` requests, compare throughput
-  - Document results
-- [ ] **4.8** Run full `--unittest` suite
-- [ ] **4.9** Run ASAN, TSAN, UBSan
-  - Confirm `__asan_handle_no_return` warnings are gone
-- [ ] **4.10** Verify build on all supported compilers
-- [ ] **4.11** Self-review and create PR #4
-- [ ] **4.12** Document final benchmark results in PR description

CONTRIBUTING.md

@@ -270,14 +270,14 @@ Before running clang-tidy, you must build the project to generate required files
 Then run clang-tidy on your local changes:
 
 ```
-run-clang-tidy -p build src include tests
+run-clang-tidy -p build -allow-no-checks src tests
 ```
 
 This will check all source files in the `src`, `include` and `tests` directories using the compile commands from your `build` directory.
 If you wish to automatically fix whatever clang-tidy finds _and_ is capable of fixing, add `-fix` to the above command:
 
 ```
-run-clang-tidy -p build -fix src include tests
+run-clang-tidy -p build -quiet -fix -allow-no-checks src tests
 ```
 
 ## Contracts and instrumentation

cmake/XrplInterface.cmake

@@ -23,6 +23,7 @@ target_compile_definitions(
         BOOST_FILESYSTEM_NO_DEPRECATED
         >
         $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
+        BOOST_COROUTINES2_NO_DEPRECATION_WARNING
         BOOST_BEAST_ALLOW_DEPRECATED
         BOOST_FILESYSTEM_DEPRECATED
         >

cmake/XrplProtocolAutogen.cmake

@@ -140,6 +140,28 @@ function(setup_protocol_autogen)
                 )
             endif()
 
+            # Check pip index URL configuration
+            execute_process(
+                COMMAND ${VENV_PIP} config get global.index-url
+                OUTPUT_VARIABLE PIP_INDEX_URL
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                ERROR_QUIET
+            )
+
+            # Default PyPI URL
+            set(DEFAULT_PIP_INDEX "https://pypi.org/simple")
+
+            # Show warning if using non-default index
+            if(PIP_INDEX_URL AND NOT PIP_INDEX_URL STREQUAL "")
+                if(NOT PIP_INDEX_URL STREQUAL DEFAULT_PIP_INDEX)
+                    message(
+                        WARNING
+                        "Private pip index URL detected: ${PIP_INDEX_URL}\n"
+                        "You may need to connect to VPN to access this URL."
+                    )
+                endif()
+            endif()
+
             message(STATUS "Installing Python dependencies...")
             execute_process(
                 COMMAND ${VENV_PIP} install --upgrade pip

cmake/deps/Boost.cmake

@@ -39,21 +39,25 @@ if(Boost_COMPILER)
     target_link_libraries(xrpl_boost INTERFACE Boost::disable_autolinking)
 endif()
 
-# Boost.Context's ucontext backend has sanitizer fiber-switching annotations
-# that are compiled in when BOOST_USE_ASAN/BOOST_USE_TSAN is defined.
-# This tells the sanitizer about fiber stack switches used by boost::asio::spawn,
-# preventing false positive errors.
-# BOOST_USE_UCONTEXT ensures the ucontext backend is selected (fcontext does
-# not support sanitizer annotations).
+# GCC 14+ has a false positive -Wuninitialized warning in Boost.Coroutine2's
+# state.hpp when compiled with -O3. This is due to GCC's intentional behavior
+# change (Bug #98871, #119388) where warnings from inlined system header code
+# are no longer suppressed by -isystem. The warning occurs in operator|= in
+# boost/coroutine2/detail/state.hpp when inlined from push_control_block::destroy().
+# See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119388
+if(is_gcc AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
+    target_compile_options(xrpl_boost INTERFACE -Wno-uninitialized)
+endif()
+
+# Boost.Context's ucontext backend has ASAN fiber-switching annotations
+# (start/finish_switch_fiber) that are compiled in when BOOST_USE_ASAN is defined.
+# This tells ASAN about coroutine stack switches, preventing false positive
+# stack-use-after-scope errors. BOOST_USE_UCONTEXT ensures the ucontext backend
+# is selected (fcontext does not support ASAN annotations).
 # These defines must match what Boost was compiled with (see conan/profiles/sanitizers).
 if(enable_asan)
     target_compile_definitions(
         xrpl_boost
         INTERFACE BOOST_USE_ASAN BOOST_USE_UCONTEXT
     )
-elseif(enable_tsan)
-    target_compile_definitions(
-        xrpl_boost
-        INTERFACE BOOST_USE_TSAN BOOST_USE_UCONTEXT
-    )
 endif()

conan.lock

@@ -1,59 +1,57 @@
 {
     "version": "0.5",
     "requires": [
-        "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1765284699.337",
+        "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809",
         "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987",
-        "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1765850149.926",
-        "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1765850149.46",
+        "sqlite3/3.51.0#66aa11eabd0e34954c5c1c061ad44abe%1774467355.988",
+        "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%1772560729.95",
-        "protobuf/6.32.1#b54f00da2e0f61d821330b5b638b0f80%1768401317.762",
-        "openssl/3.5.5#e6399de266349245a4542fc5f6c71552%1774367199.56",
-        "nudb/2.0.9#0432758a24204da08fee953ec9ea03cb%1769436073.32",
+        "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",
         "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",
         "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1768312129.152",
-        "grpc/1.72.0#aaade9421980b2d926dbfb613d56c38a%1774376249.106",
+        "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%1766500685.317",
+        "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1774439234.681",
         "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837",
         "boost/1.90.0#d5e8defe7355494953be18524a7f135b%1769454080.269",
         "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196"
     ],
     "build_requires": [
-        "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1765284699.337",
-        "strawberryperl/5.32.1.1#8d114504d172cfea8ea1662d09b6333e%1751971032.423",
-        "protobuf/6.32.1#b54f00da2e0f61d821330b5b638b0f80%1768401317.762",
+        "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809",
+        "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",
-        "cmake/4.3.0#b939a42e98f593fb34d3a8c5cc860359%1773780142.26",
-        "cmake/3.31.11#f325c933f618a1fcebc1e1c0babfd1ba%1769622857.944",
-        "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1766594659.866",
+        "cmake/4.3.0#b939a42e98f593fb34d3a8c5cc860359%1774439249.183",
+        "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1774439233.447",
         "automake/1.16.5#b91b7c384c3deaa9d535be02da14d04f%1755524470.56",
         "autoconf/2.71#51077f068e61700d65bb05541ea1e4b0%1731054366.86",
         "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196"
     ],
     "python_requires": [],
     "overrides": {
-        "boost/1.90.0#d5e8defe7355494953be18524a7f135b": [
-            null,
-            "boost/1.90.0"
-        ],
         "protobuf/[>=5.27.0 <7]": [
-            "protobuf/6.32.1"
+            "protobuf/6.33.5"
         ],
         "lz4/1.9.4": [
             "lz4/1.10.0"
         ],
+        "boost/[>=1.83.0 <1.91.0]": [
+            "boost/1.90.0"
+        ],
         "sqlite3/[>=3.44 <4]": [
-            "sqlite3/3.49.1"
+            "sqlite3/3.51.0"
         ],
         "boost/1.83.0": [
             "boost/1.90.0"

conan/profiles/sanitizers

@@ -82,12 +82,5 @@ tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags"
         boost/*:without_context=False
         # Boost stacktrace fails to build with some sanitizers
         boost/*:without_stacktrace=True
-    {% elif "thread" in sanitizers %}
-        # Build Boost.Context with ucontext backend (not fcontext) so that
-        # TSAN can track fiber/context switches made by boost::asio::spawn.
-        # fcontext uses raw assembly that TSAN cannot instrument.
-        boost/*:extra_b2_flags=context-impl=ucontext thread-sanitizer=on define=BOOST_USE_TSAN=1
-        boost/*:without_context=False
-        boost/*:without_stacktrace=True
     {% endif %}
 {% endif %}

conanfile.py

@@ -4,7 +4,6 @@ import re
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 
 from conan import ConanFile
-from conan import __version__ as conan_version
 
 
 class Xrpl(ConanFile):
@@ -30,10 +29,10 @@ class Xrpl(ConanFile):
 
     requires = [
         "ed25519/2015.03",
-        "grpc/1.72.0",
+        "grpc/1.78.1",
         "libarchive/3.8.1",
         "nudb/2.0.9",
-        "openssl/3.5.5",
+        "openssl/3.6.1",
         "secp256k1/0.7.1",
         "soci/4.0.3",
         "zlib/1.3.1",
@@ -44,7 +43,7 @@ class Xrpl(ConanFile):
     ]
 
     tool_requires = [
-        "protobuf/6.32.1",
+        "protobuf/6.33.5",
     ]
 
     default_options = {
@@ -60,7 +59,7 @@ class Xrpl(ConanFile):
         "xrpld": False,
         "boost/*:without_context": False,
         "boost/*:without_coroutine": True,
-        "boost/*:without_coroutine2": True,
+        "boost/*:without_coroutine2": False,
         "date/*:header_only": True,
         "ed25519/*:shared": False,
         "grpc/*:shared": False,
@@ -137,20 +136,16 @@ class Xrpl(ConanFile):
                 self.default_options["fPIC"] = False
 
     def requirements(self):
-        # Conan 2 requires transitive headers to be specified
-        transitive_headers_opt = (
-            {"transitive_headers": True} if conan_version.split(".")[0] == "2" else {}
-        )
-        self.requires("boost/1.90.0", force=True, **transitive_headers_opt)
-        self.requires("date/3.0.4", **transitive_headers_opt)
+        self.requires("boost/1.90.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.32.1", force=True)
-        self.requires("sqlite3/3.49.1", force=True)
+        self.requires("protobuf/6.33.5", force=True)
+        self.requires("sqlite3/3.51.0", force=True)
         if self.options.jemalloc:
             self.requires("jemalloc/5.3.0")
         if self.options.rocksdb:
             self.requires("rocksdb/10.5.1")
-        self.requires("xxhash/0.8.3", **transitive_headers_opt)
+        self.requires("xxhash/0.8.3", transitive_headers=True)
 
     exports_sources = (
         "CMakeLists.txt",

cspell.config.yaml

@@ -70,7 +70,6 @@ words:
   - coeffs
   - coldwallet
   - compr
-  - cppcoro
   - conanfile
   - conanrun
   - confs
@@ -98,7 +97,6 @@ words:
   - doxyfile
   - dxrpl
   - endmacro
-  - eventfd
   - exceptioned
   - Falco
   - fcontext
@@ -107,7 +105,6 @@ words:
   - fmtdur
   - fsanitize
   - funclets
-  - gantt
   - gcov
   - gcovr
   - ghead
@@ -151,7 +148,6 @@ words:
   - ltype
   - mcmodel
   - MEMORYSTATUSEX
-  - Mankawde
   - Merkle
   - Metafuncton
   - misprediction
@@ -200,7 +196,6 @@ words:
   - permissioned
   - pointee
   - populator
-  - pratik
   - preauth
   - preauthorization
   - preauthorize
@@ -209,7 +204,6 @@ words:
   - protobuf
   - protos
   - ptrs
-  - Pratik
   - pushd
   - pyenv
   - pyparsing
@@ -217,8 +211,6 @@ words:
   - queuable
   - Raphson
   - replayer
-  - repost
-  - reposts
   - rerere
   - retriable
   - RIPD
@@ -250,7 +242,6 @@ words:
   - soci
   - socidb
   - sslws
-  - stackful
   - statsd
   - STATSDCOLLECTOR
   - stissue
@@ -269,7 +260,6 @@ words:
   - takerpays
   - ters
   - TMEndpointv2
-  - TOCTOU
   - trixie
   - tx
   - txid

include/xrpl/basics/BasicConfig.h

@@ -311,7 +311,7 @@ template <class T>
 bool
 set(T& target, T const& defaultValue, std::string const& name, Section const& section)
 {
-    bool found_and_valid = set<T>(target, name, section);
+    bool const found_and_valid = set<T>(target, name, section);
     if (!found_and_valid)
         target = defaultValue;
     return found_and_valid;

include/xrpl/basics/CountedObject.h

@@ -34,7 +34,7 @@ public:
         {
             // Insert ourselves at the front of the lock-free linked list
             CountedObjects& instance = CountedObjects::getInstance();
-            Counter* head;
+            Counter* head = nullptr;
 
             do
             {

include/xrpl/basics/DecayingSample.h

@@ -93,7 +93,7 @@ class DecayWindow
 public:
     using time_point = typename Clock::time_point;
 
-    explicit DecayWindow(time_point now) : value_(0), when_(now)
+    explicit DecayWindow(time_point now) : when_(now)
     {
     }
 
@@ -125,7 +125,7 @@ private:
         when_ = now;
     }
 
-    double value_;
+    double value_{0};
     time_point when_;
 };
 

include/xrpl/basics/IntrusivePointer.h

@@ -84,7 +84,8 @@ public:
 
     template <class TT>
         requires std::convertible_to<TT*, T*>
-    SharedIntrusive(SharedIntrusive<TT>&& rhs);
+    SharedIntrusive(
+        SharedIntrusive<TT>&& rhs);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
 
     SharedIntrusive&
     operator=(SharedIntrusive const& rhs);
@@ -106,7 +107,8 @@ public:
     template <class TT>
         requires std::convertible_to<TT*, T*>
     SharedIntrusive&
-    operator=(SharedIntrusive<TT>&& rhs);
+    operator=(
+        SharedIntrusive<TT>&& rhs);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
 
     /** Adopt the raw pointer. The strong reference may or may not be
         incremented, depending on the TAdoptTag
@@ -314,7 +316,8 @@ public:
 
     template <class TT>
         requires std::convertible_to<TT*, T*>
-    SharedWeakUnion(SharedIntrusive<TT>&& rhs);
+    SharedWeakUnion(
+        SharedIntrusive<TT>&& rhs);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
 
     SharedWeakUnion&
     operator=(SharedWeakUnion const& rhs);
@@ -327,7 +330,8 @@ public:
     template <class TT>
         requires std::convertible_to<TT*, T*>
     SharedWeakUnion&
-    operator=(SharedIntrusive<TT>&& rhs);
+    operator=(
+        SharedIntrusive<TT>&& rhs);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
 
     ~SharedWeakUnion();
 

include/xrpl/basics/IntrusivePointer.ipp

@@ -68,9 +68,7 @@ SharedIntrusive<T>::operator=(SharedIntrusive const& rhs)
 
 template <class T>
 template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
+    requires std::convertible_to<TT*, T*>
 SharedIntrusive<T>&
 SharedIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
 {
@@ -101,9 +99,7 @@ SharedIntrusive<T>::operator=(SharedIntrusive&& rhs)
 
 template <class T>
 template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
+    requires std::convertible_to<TT*, T*>
 SharedIntrusive<T>&
 SharedIntrusive<T>::operator=(SharedIntrusive<TT>&& rhs)
 {
@@ -307,9 +303,7 @@ WeakIntrusive<T>::WeakIntrusive(SharedIntrusive<T> const& rhs) : ptr_{rhs.unsafe
 
 template <class T>
 template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
+    requires std::convertible_to<TT*, T*>
 WeakIntrusive<T>&
 WeakIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
 {
@@ -454,9 +448,7 @@ SharedWeakUnion<T>::operator=(SharedWeakUnion const& rhs)
 
 template <class T>
 template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
+    requires std::convertible_to<TT*, T*>
 SharedWeakUnion<T>&
 SharedWeakUnion<T>::operator=(SharedIntrusive<TT> const& rhs)
 {
@@ -470,9 +462,7 @@ SharedWeakUnion<T>::operator=(SharedIntrusive<TT> const& rhs)
 
 template <class T>
 template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
+    requires std::convertible_to<TT*, T*>
 SharedWeakUnion<T>&
 SharedWeakUnion<T>::operator=(SharedIntrusive<TT>&& rhs)
 {

include/xrpl/basics/IntrusiveRefCounts.h

@@ -448,7 +448,7 @@ inline void
 partialDestructorFinished(T** o)
 {
     T& self = **o;
-    IntrusiveRefCounts::RefCountPair p =
+    IntrusiveRefCounts::RefCountPair const p =
         self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
     XRPL_ASSERT(
         (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong),

include/xrpl/basics/Number.h

@@ -73,12 +73,12 @@ struct MantissaRange
     enum mantissa_scale { small, large };
 
     explicit constexpr MantissaRange(mantissa_scale scale_)
-        : min(getMin(scale_)), max(min * 10 - 1), log(logTen(min).value_or(-1)), scale(scale_)
+        : min(getMin(scale_)), log(logTen(min).value_or(-1)), scale(scale_)
     {
     }
 
     rep min;
-    rep max;
+    rep max{min * 10 - 1};
     int log;
     mantissa_scale scale;
 

include/xrpl/basics/SlabAllocator.h

@@ -91,10 +91,10 @@ class SlabAllocator
         std::uint8_t*
         allocate() noexcept
         {
-            std::uint8_t* ret;
+            std::uint8_t* ret = nullptr;  // NOLINT(misc-const-correctness)
 
             {
-                std::lock_guard l(m_);
+                std::lock_guard const l(m_);
 
                 ret = l_;
 
@@ -123,7 +123,7 @@ class SlabAllocator
         {
             XRPL_ASSERT(own(ptr), "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
 
-            std::lock_guard l(m_);
+            std::lock_guard const l(m_);
 
             // Use memcpy to avoid unaligned UB
             // (will optimize to equivalent code)
@@ -210,16 +210,13 @@ public:
 
         // No slab can satisfy our request, so we attempt to allocate a new
         // one here:
-        std::size_t size = slabSize_;
+        std::size_t const size = slabSize_;
 
         // We want to allocate the memory at a 2 MiB boundary, to make it
         // possible to use hugepage mappings on Linux:
         auto buf = boost::alignment::aligned_alloc(megabytes(std::size_t(2)), size);
-
-        // clang-format off
         if (!buf) [[unlikely]]
             return nullptr;
-        // clang-format on
 
 #if BOOST_OS_LINUX
         // When allocating large blocks, attempt to leverage Linux's

include/xrpl/basics/StringUtilities.h

@@ -66,12 +66,12 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     while (iter != end)
     {
-        int cHigh = digitLookupTable[*iter++];
+        int const cHigh = digitLookupTable[*iter++];
 
         if (cHigh < 0)
             return {};
 
-        int cLow = digitLookupTable[*iter++];
+        int const cLow = digitLookupTable[*iter++];
 
         if (cLow < 0)
             return {};

include/xrpl/basics/TaggedCache.h

@@ -182,8 +182,7 @@ private:
             : hook(collector->make_hook(handler))
             , size(collector->make_gauge(prefix, "size"))
             , hit_rate(collector->make_gauge(prefix, "hit_rate"))
-            , hits(0)
-            , misses(0)
+
         {
         }
 
@@ -191,8 +190,8 @@ private:
         beast::insight::Gauge size;
         beast::insight::Gauge hit_rate;
 
-        std::size_t hits;
-        std::size_t misses;
+        std::size_t hits{0};
+        std::size_t misses{0};
     };
 
     class KeyOnlyEntry
@@ -294,10 +293,10 @@ private:
     clock_type::duration const m_target_age;
 
     // Number of items cached
-    int m_cache_count;
+    int m_cache_count{0};
     cache_type m_cache;  // Hold strong reference to recent objects
-    std::uint64_t m_hits;
-    std::uint64_t m_misses;
+    std::uint64_t m_hits{0};
+    std::uint64_t m_misses{0};
 };
 
 }  // namespace xrpl

include/xrpl/basics/TaggedCache.ipp

@@ -36,9 +36,7 @@ inline TaggedCache<
     , m_name(name)
     , m_target_size(size)
     , m_target_age(expiration)
-    , m_cache_count(0)
-    , m_hits(0)
-    , m_misses(0)
+
 {
 }
 

include/xrpl/basics/base_uint.h

@@ -212,7 +212,7 @@ private:
         while (in != sv.end())
         {
             std::uint32_t accum = {};
-            for (std::uint32_t shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
+            for (std::uint32_t const shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
             {
                 if (auto const result = hexCharToUInt(*in++, shift, accum);
                     result != ParseResult::okay)
@@ -335,11 +335,13 @@ public:
     operator=(std::uint64_t uHost)
     {
         *this = beast::zero;
+        // NOLINTBEGIN(cppcoreguidelines-pro-type-member-init)
         union
         {
             unsigned u[2];
             std::uint64_t ul;
         };
+        // NOLINTEND(cppcoreguidelines-pro-type-member-init)
         // Put in least significant bits.
         ul = boost::endian::native_to_big(uHost);
         data_[WIDTH - 2] = u[0];
@@ -444,7 +446,7 @@ public:
 
         for (int i = WIDTH; i--;)
         {
-            std::uint64_t n = carry + boost::endian::big_to_native(data_[i]) +
+            std::uint64_t const n = carry + boost::endian::big_to_native(data_[i]) +
                 boost::endian::big_to_native(b.data_[i]);
 
             data_[i] = boost::endian::native_to_big(static_cast<std::uint32_t>(n));
@@ -621,7 +623,7 @@ template <>
 inline std::size_t
 extract(uint256 const& key)
 {
-    std::size_t result;
+    std::size_t result = 0;
     // Use memcpy to avoid unaligned UB
     // (will optimize to equivalent code)
     std::memcpy(&result, key.data(), sizeof(std::size_t));

include/xrpl/basics/contract.h

@@ -54,7 +54,7 @@ Throw(Args&&... args)
 
     E e(std::forward<Args>(args)...);
     LogThrow(std::string("Throwing exception of type " + beast::type_name<E>() + ": ") + e.what());
-    throw e;
+    throw std::move(e);
 }
 
 /** Called when faulty logic causes a broken invariant. */

include/xrpl/basics/hardened_hash.h

@@ -32,7 +32,7 @@ make_seed_pair() noexcept
         // state_t& operator=(state_t const&) = delete;
     };
     static state_t state;
-    std::lock_guard lock(state.mutex);
+    std::lock_guard const lock(state.mutex);
     return {state.dist(state.gen), state.dist(state.gen)};
 }
 

include/xrpl/basics/random.h

@@ -14,11 +14,13 @@ namespace xrpl {
 
 #ifndef __INTELLISENSE__
 static_assert(
+    // NOLINTNEXTLINE(misc-redundant-expression)
     std::is_integral<beast::xor_shift_engine::result_type>::value &&
         std::is_unsigned<beast::xor_shift_engine::result_type>::value,
     "The Ripple default PRNG engine must return an unsigned integral type.");
 
 static_assert(
+    // NOLINTNEXTLINE(misc-redundant-expression)
     std::numeric_limits<beast::xor_shift_engine::result_type>::max() >=
         std::numeric_limits<std::uint64_t>::max(),
     "The Ripple default PRNG engine return must be at least 64 bits wide.");
@@ -56,9 +58,9 @@ default_prng()
 
     // The thread-specific PRNGs:
     thread_local beast::xor_shift_engine engine = [] {
-        std::uint64_t seed;
+        std::uint64_t seed = 0;
         {
-            std::lock_guard lk(m);
+            std::lock_guard const lk(m);
             std::uniform_int_distribution<std::uint64_t> distribution{1};
             seed = distribution(seeder);
         }

include/xrpl/beast/asio/io_latency_probe.h

@@ -23,15 +23,15 @@ private:
 
     std::recursive_mutex m_mutex;
     std::condition_variable_any m_cond;
-    std::size_t m_count;
+    std::size_t m_count{1};
     duration const m_period;
     boost::asio::io_context& m_ios;
     boost::asio::basic_waitable_timer<std::chrono::steady_clock> m_timer;
-    bool m_cancel;
+    bool m_cancel{false};
 
 public:
     io_latency_probe(duration const& period, boost::asio::io_context& ios)
-        : m_count(1), m_period(period), m_ios(ios), m_timer(m_ios), m_cancel(false)
+        : m_period(period), m_ios(ios), m_timer(m_ios)
     {
     }
 
@@ -83,7 +83,7 @@ public:
     void
     sample_one(Handler&& handler)
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
@@ -98,7 +98,7 @@ public:
     void
     sample(Handler&& handler)
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
@@ -122,14 +122,14 @@ private:
     void
     addref()
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         ++m_count;
     }
 
     void
     release()
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         if (--m_count == 0)
             m_cond.notify_all();
     }
@@ -192,7 +192,7 @@ private:
             m_handler(elapsed);
 
             {
-                std::lock_guard lock(m_probe->m_mutex);
+                std::lock_guard const lock(m_probe->m_mutex);
                 if (m_probe->m_cancel)
                     return;
             }

include/xrpl/beast/container/aged_map.h

@@ -16,4 +16,4 @@ template <
     class Allocator = std::allocator<std::pair<Key const, T>>>
 using aged_map = detail::aged_ordered_container<false, true, Key, T, Clock, Compare, Allocator>;
 
-}
+}  // namespace beast

include/xrpl/beast/container/aged_multimap.h

@@ -16,4 +16,4 @@ template <
     class Allocator = std::allocator<std::pair<Key const, T>>>
 using aged_multimap = detail::aged_ordered_container<true, true, Key, T, Clock, Compare, Allocator>;
 
-}
+}  // namespace beast

include/xrpl/beast/container/aged_multiset.h

@@ -15,4 +15,4 @@ template <
     class Allocator = std::allocator<Key>>
 using aged_multiset =
     detail::aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
-}
+}  // namespace beast

include/xrpl/beast/container/aged_set.h

@@ -15,4 +15,4 @@ template <
     class Allocator = std::allocator<Key>>
 using aged_set = detail::aged_ordered_container<false, false, Key, void, Clock, Compare, Allocator>;
 
-}
+}  // namespace beast

include/xrpl/beast/container/aged_unordered_map.h

@@ -17,4 +17,4 @@ template <
     class Allocator = std::allocator<std::pair<Key const, T>>>
 using aged_unordered_map =
     detail::aged_unordered_container<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
-}
+}  // namespace beast

include/xrpl/beast/container/aged_unordered_multimap.h

@@ -17,4 +17,4 @@ template <
     class Allocator = std::allocator<std::pair<Key const, T>>>
 using aged_unordered_multimap =
     detail::aged_unordered_container<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
-}
+}  // namespace beast

include/xrpl/beast/container/aged_unordered_multiset.h

@@ -17,4 +17,4 @@ template <
 using aged_unordered_multiset =
     detail::aged_unordered_container<true, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
 
-}
+}  // namespace beast

include/xrpl/beast/container/aged_unordered_set.h

@@ -16,4 +16,4 @@ template <
     class Allocator = std::allocator<Key>>
 using aged_unordered_set =
     detail::aged_unordered_container<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
-}
+}  // namespace beast

include/xrpl/beast/container/detail/aged_ordered_container.h

@@ -262,7 +262,9 @@ private:
         {
         }
 
-        config_t(config_t&& other, Allocator const& alloc)
+        config_t(
+            config_t&& other,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
+            Allocator const& alloc)
             : KeyValueCompare(std::move(other.key_compare()))
             , beast::detail::empty_base_optimization<ElementAllocator>(alloc)
             , clock(other.clock)
@@ -552,7 +554,10 @@ public:
 
     aged_ordered_container(aged_ordered_container&& other);
 
-    aged_ordered_container(aged_ordered_container&& other, Allocator const& alloc);
+    aged_ordered_container(
+        // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
+        aged_ordered_container&& other,
+        Allocator const& alloc);
 
     aged_ordered_container(std::initializer_list<value_type> init, clock_type& clock);
 
@@ -1290,7 +1295,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::aged_
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::aged_ordered_container(
-    aged_ordered_container&& other,
+    aged_ordered_container&& other,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
     Allocator const& alloc)
     : m_config(std::move(other.m_config), alloc)
 #if BOOST_VERSION >= 108000

include/xrpl/beast/container/detail/aged_unordered_container.h

@@ -318,7 +318,9 @@ private:
         {
         }
 
-        config_t(config_t&& other, Allocator const& alloc)
+        config_t(
+            config_t&& other,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
+            Allocator const& alloc)
             : ValueHash(std::move(other.hash_function()))
             , KeyValueEqual(std::move(other.key_eq()))
             , beast::detail::empty_base_optimization<ElementAllocator>(alloc)
@@ -774,7 +776,10 @@ public:
 
     aged_unordered_container(aged_unordered_container&& other);
 
-    aged_unordered_container(aged_unordered_container&& other, Allocator const& alloc);
+    aged_unordered_container(
+        // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
+        aged_unordered_container&& other,
+        Allocator const& alloc);
 
     aged_unordered_container(std::initializer_list<value_type> init, clock_type& clock);
 
@@ -1838,7 +1843,10 @@ template <
     class KeyEqual,
     class Allocator>
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    aged_unordered_container(aged_unordered_container&& other, Allocator const& alloc)
+    aged_unordered_container(
+        // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
+        aged_unordered_container&& other,
+        Allocator const& alloc)
     : m_config(std::move(other.m_config), alloc)
     , m_buck(alloc)
     , m_cont(m_buck, std::cref(m_config.value_hash()), std::cref(m_config.key_value_equal()))

include/xrpl/beast/core/List.h

@@ -449,7 +449,7 @@ public:
     iterator
     erase(iterator pos) noexcept
     {
-        Node* node = &*pos;
+        Node const* node = &*pos;
         ++pos;
         node->m_next->m_prev = node->m_prev;
         node->m_prev->m_next = node->m_next;

include/xrpl/beast/core/LockFreeStack.h

@@ -187,7 +187,7 @@ public:
     bool
     push_front(Node* node)
     {
-        bool first;
+        bool first = false;
         Node* old_head = m_head.load(std::memory_order_relaxed);
         do
         {
@@ -211,7 +211,7 @@ public:
     pop_front()
     {
         Node* node = m_head.load();
-        Node* new_head;
+        Node* new_head = nullptr;
         do
         {
             if (node == &m_end)

include/xrpl/beast/hash/xxhasher.h

@@ -23,7 +23,7 @@ private:
     // A 64-byte buffer should to be big enough for us
     static constexpr std::size_t INTERNAL_BUFFER_SIZE = 64;
 
-    alignas(64) std::array<std::uint8_t, INTERNAL_BUFFER_SIZE> buffer_;
+    alignas(64) std::array<std::uint8_t, INTERNAL_BUFFER_SIZE> buffer_{};
     std::span<std::uint8_t> readBuffer_;
     std::span<std::uint8_t> writeBuffer_;
 

include/xrpl/beast/test/yield_to.h

@@ -114,7 +114,7 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
         boost::context::fixedsize_stack(2 * 1024 * 1024),
         [&](yield_context yield) {
             f(yield);
-            std::lock_guard lock{m_};
+            std::lock_guard const lock{m_};
             if (--running_ == 0)
                 cv_.notify_all();
         },

include/xrpl/beast/unit_test/results.h

@@ -35,10 +35,10 @@ private:
     class tests_t : public detail::const_container<std::vector<test>>
     {
     private:
-        std::size_t failed_;
+        std::size_t failed_{0};
 
     public:
-        tests_t() : failed_(0)
+        tests_t()
         {
         }
 
@@ -167,12 +167,12 @@ public:
 class results : public detail::const_container<std::vector<suite_results>>
 {
 private:
-    std::size_t m_cases;
-    std::size_t total_;
-    std::size_t failed_;
+    std::size_t m_cases{0};
+    std::size_t total_{0};
+    std::size_t failed_{0};
 
 public:
-    results() : m_cases(0), total_(0), failed_(0)
+    results()
     {
     }
 

include/xrpl/beast/unit_test/runner.h

@@ -228,7 +228,7 @@ template <class>
 void
 runner::testcase(std::string const& name)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     // Name may not be empty
     BOOST_ASSERT(default_ || !name.empty());
     // Forgot to call pass or fail
@@ -244,7 +244,7 @@ template <class>
 void
 runner::pass()
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (default_)
         testcase("");
     on_pass();
@@ -255,7 +255,7 @@ template <class>
 void
 runner::fail(std::string const& reason)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (default_)
         testcase("");
     on_fail(reason);
@@ -267,7 +267,7 @@ template <class>
 void
 runner::log(std::string const& s)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (default_)
         testcase("");
     on_log(s);

include/xrpl/beast/unit_test/suite.h

@@ -300,7 +300,7 @@ private:
     static suite**
     p_this_suite()
     {
-        static suite* pts = nullptr;
+        static suite* pts = nullptr;  // NOLINT(misc-const-correctness)
         return &pts;
     }
 

include/xrpl/beast/utility/PropertyStream.h

@@ -311,7 +311,7 @@ private:
     std::string const m_name;
     std::recursive_mutex lock_;
     Item item_;
-    Source* parent_;
+    Source* parent_{nullptr};
     List<Item> children_;
 
 public:

include/xrpl/beast/utility/Zero.h

@@ -28,7 +28,7 @@ struct Zero
 
 namespace {
 static constexpr Zero zero{};
-}
+}  // namespace
 
 /** Default implementation of signum calls the method on the class. */
 template <typename T>

include/xrpl/beast/xor_shift_engine.h

@@ -37,7 +37,7 @@ public:
     }
 
 private:
-    result_type s_[2];
+    result_type s_[2]{};
 
     static result_type
     murmurhash3(result_type x);

include/xrpl/core/ClosureCounter.h

@@ -56,7 +56,7 @@ private:
         // a lock.  This removes a small timing window that occurs if the
         // waiting thread is handling a spurious wakeup when closureCount_
         // drops to zero.
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
 
         // Update closureCount_.  Notify if stopping and closureCount_ == 0.
         if ((--closureCount_ == 0) && waitForClosures_)
@@ -92,7 +92,9 @@ private:
             ++counter_;
         }
 
-        Substitute(ClosureCounter& counter, Closure&& closure)
+        Substitute(
+            ClosureCounter& counter,
+            Closure&& closure)  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
             : counter_(counter), closure_(std::forward<Closure>(closure))
         {
             ++counter_;
@@ -168,7 +170,7 @@ public:
     {
         std::optional<Substitute<Closure>> ret;
 
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         if (!waitForClosures_)
             ret.emplace(*this, std::forward<Closure>(closure));
 
@@ -191,7 +193,7 @@ public:
     bool
     joined() const
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return waitForClosures_;
     }
 };

include/xrpl/core/Coro.ipp

@@ -0,0 +1,131 @@
+#pragma once
+
+namespace xrpl {
+
+template <class F>
+JobQueue::Coro::Coro(Coro_create_t, JobQueue& jq, JobType type, std::string const& name, F&& f)
+    : jq_(jq)
+    , type_(type)
+    , name_(name)
+    , coro_(
+          // Stack size of 1MB wasn't sufficient for deep calls. ASAN tests flagged the issue. Hence
+          // increasing the size to 1.5MB.
+          boost::context::protected_fixedsize_stack(1536 * 1024),
+          [this, fn = std::forward<F>(f)](
+              boost::coroutines2::asymmetric_coroutine<void>::push_type& do_yield) {
+              yield_ = &do_yield;
+              yield();
+              fn(shared_from_this());
+#ifndef NDEBUG
+              finished_ = true;
+#endif
+          })
+{
+}
+
+inline JobQueue::Coro::~Coro()
+{
+#ifndef NDEBUG
+    XRPL_ASSERT(finished_, "xrpl::JobQueue::Coro::~Coro : is finished");
+#endif
+}
+
+inline void
+JobQueue::Coro::yield() const
+{
+    {
+        std::lock_guard lock(jq_.m_mutex);
+        ++jq_.nSuspend_;
+    }
+    (*yield_)();
+}
+
+inline bool
+JobQueue::Coro::post()
+{
+    {
+        std::lock_guard lk(mutex_run_);
+        running_ = true;
+    }
+
+    // sp keeps 'this' alive
+    if (jq_.addJob(type_, name_, [this, sp = shared_from_this()]() { resume(); }))
+    {
+        return true;
+    }
+
+    // The coroutine will not run.  Clean up running_.
+    std::lock_guard lk(mutex_run_);
+    running_ = false;
+    cv_.notify_all();
+    return false;
+}
+
+inline void
+JobQueue::Coro::resume()
+{
+    {
+        std::lock_guard lk(mutex_run_);
+        running_ = true;
+    }
+    {
+        std::lock_guard lk(jq_.m_mutex);
+        --jq_.nSuspend_;
+    }
+    auto saved = detail::getLocalValues().release();
+    detail::getLocalValues().reset(&lvs_);
+    std::lock_guard lock(mutex_);
+    // A late resume() can arrive after the coroutine has already completed.
+    // This is an expected (if rare) outcome of the race condition documented
+    // in JobQueue.h:354-377 where post() schedules a resume job before the
+    // coroutine yields — the mutex serializes access, but by the time this
+    // resume() acquires the lock the coroutine may have already run to
+    // completion. Calling operator() on a completed boost::coroutine2 is
+    // undefined behavior, so we must check and skip invoking the coroutine
+    // body if it has already completed.
+    if (coro_)
+    {
+        coro_();
+    }
+    detail::getLocalValues().release();
+    detail::getLocalValues().reset(saved);
+    std::lock_guard lk(mutex_run_);
+    running_ = false;
+    cv_.notify_all();
+}
+
+inline bool
+JobQueue::Coro::runnable() const
+{
+    return static_cast<bool>(coro_);
+}
+
+inline void
+JobQueue::Coro::expectEarlyExit()
+{
+#ifndef NDEBUG
+    if (!finished_)
+#endif
+    {
+        // expectEarlyExit() must only ever be called from outside the
+        // Coro's stack.  It you're inside the stack you can simply return
+        // and be done.
+        //
+        // That said, since we're outside the Coro's stack, we need to
+        // decrement the nSuspend that the Coro's call to yield caused.
+        std::lock_guard lock(jq_.m_mutex);
+        --jq_.nSuspend_;
+#ifndef NDEBUG
+        finished_ = true;
+#endif
+    }
+}
+
+inline void
+JobQueue::Coro::join()
+{
+    std::unique_lock<std::mutex> lk(mutex_run_);
+    cv_.wait(lk, [this]() { return running_ == false; });
+}
+
+}  // namespace xrpl

include/xrpl/core/CoroTask.h

@@ -1,699 +0,0 @@
-#pragma once
-
-#include <xrpl/beast/utility/instrumentation.h>
-
-#include <coroutine>
-#include <exception>
-#include <type_traits>
-#include <utility>
-#include <variant>
-
-namespace xrpl {
-
-template <typename T = void>
-class CoroTask;
-
-/**
- * CoroTask<void> -- coroutine return type for void-returning coroutines.
- *
- * Class / Dependency Diagram
- * ==========================
- *
- *   CoroTask<void>
- *   +-----------------------------------------------+
- *   | - handle_ : Handle (coroutine_handle<promise>) |
- *   +-----------------------------------------------+
- *   | + handle(), done()                             |
- *   | + await_ready/suspend/resume  (Awaiter iface)  |
- *   +-----------------------------------------------+
- *            |  owns
- *            v
- *   promise_type
- *   +-----------------------------------------------+
- *   | - exception_    : std::exception_ptr           |
- *   | - continuation_ : std::coroutine_handle<>      |
- *   +-----------------------------------------------+
- *   | + get_return_object() -> CoroTask              |
- *   | + initial_suspend()   -> suspend_always (lazy) |
- *   | + final_suspend()     -> FinalAwaiter          |
- *   | + return_void()                                |
- *   | + unhandled_exception()                        |
- *   +-----------------------------------------------+
- *            |  returns at final_suspend
- *            v
- *   FinalAwaiter
- *   +-----------------------------------------------+
- *   | await_suspend(h):                              |
- *   |   if continuation_ set -> symmetric transfer   |
- *   |   else                 -> noop_coroutine        |
- *   +-----------------------------------------------+
- *
- * Design Notes
- * ------------
- * - Lazy start: initial_suspend returns suspend_always, so the coroutine
- *   body does not execute until the handle is explicitly resumed.
- * - Symmetric transfer: await_suspend returns a coroutine_handle instead
- *   of void/bool, allowing the scheduler to jump directly to the next
- *   coroutine without growing the call stack.
- * - Continuation chaining: when one CoroTask is co_await-ed inside
- *   another, the caller's handle is stored as continuation_ so
- *   FinalAwaiter can resume it when this task finishes.
- * - Move-only: the handle is exclusively owned; copy is deleted.
- *
- * Usage Examples
- * ==============
- *
- * 1. Basic void coroutine (the most common case in rippled):
- *
- *      CoroTask<void> doWork(std::shared_ptr<CoroTaskRunner> runner) {
- *          // do something
- *          co_await runner->suspend();   // yield control
- *          // resumed later via runner->post() or runner->resume()
- *          co_return;
- *      }
- *
- * 2. co_await-ing one CoroTask<void> from another (chaining):
- *
- *      CoroTask<void> inner() {
- *          // ...
- *          co_return;
- *      }
- *      CoroTask<void> outer() {
- *          co_await inner();   // continuation_ links outer -> inner
- *          co_return;          // FinalAwaiter resumes outer
- *      }
- *
- * 3. Exceptions propagate through co_await:
- *
- *      CoroTask<void> failing() {
- *          throw std::runtime_error("oops");
- *          co_return;
- *      }
- *      CoroTask<void> caller() {
- *          try { co_await failing(); }
- *          catch (std::runtime_error const&) { // caught here }
- *      }
- *
- * Caveats / Pitfalls
- * ==================
- *
- * BUG-RISK: Dangling references in coroutine parameters.
- *   Coroutine parameters are copied into the frame, but references
- *   are NOT -- they are stored as-is. If the referent goes out of scope
- *   before the coroutine finishes, you get use-after-free.
- *
- *      // BROKEN -- local dies before coroutine runs:
- *      CoroTask<void> bad(int& ref) { co_return; }
- *      void launch() {
- *          int local = 42;
- *          auto task = bad(local);  // frame stores &local
- *      }  // local destroyed; frame holds dangling ref
- *
- *      // FIX -- pass by value, or ensure lifetime via shared_ptr.
- *
- * BUG-RISK: GCC 14 corrupts reference captures in coroutine lambdas.
- *   When a lambda that returns CoroTask captures by reference ([&]),
- *   GCC 14 may generate a corrupted coroutine frame. Always capture
- *   by explicit pointer-to-value instead:
- *
- *      // BROKEN on GCC 14:
- *      jq.postCoroTask(t, n, [&](auto) -> CoroTask<void> { ... });
- *
- *      // FIX -- capture pointers explicitly:
- *      jq.postCoroTask(t, n, [ptr = &val](auto) -> CoroTask<void> { ... });
- *
- * BUG-RISK: Resuming a destroyed or completed CoroTask.
- *   Calling handle().resume() after the coroutine has already run to
- *   completion (done() == true) is undefined behavior. The CoroTaskRunner
- *   guards against this with an XRPL_ASSERT, but standalone usage of
- *   CoroTask must check done() before resuming.
- *
- * BUG-RISK: Moving a CoroTask that is being awaited.
- *   If task A is co_await-ed by task B (so A.continuation_ == B), moving
- *   or destroying A will invalidate the continuation link. Never move
- *   or reassign a CoroTask while it is mid-execution or being awaited.
- *
- * LIMITATION: CoroTask is fire-and-forget for the top-level owner.
- *   There is no built-in notification when the coroutine finishes.
- *   The caller must use external synchronization (e.g. CoroTaskRunner::join
- *   or a gate/condition_variable) to know when it is done.
- *
- * LIMITATION: No cancellation token.
- *   There is no way to cancel a suspended CoroTask from outside. The
- *   coroutine body must cooperatively check a flag (e.g. jq_.isStopping())
- *   after each co_await and co_return early if needed.
- *
- * LIMITATION: Stackless -- cannot suspend from nested non-coroutine calls.
- *   If a coroutine calls a regular function that wants to "yield", it
- *   cannot. Only the immediate coroutine body can use co_await.
- *   This is acceptable for rippled because all yield() sites are shallow.
- */
-template <>
-class CoroTask<void>
-{
-public:
-    struct promise_type;
-    using Handle = std::coroutine_handle<promise_type>;
-
-    /**
-     * Coroutine promise. Compiler uses this to manage coroutine state.
-     * Stores the exception (if any) and the continuation handle for
-     * symmetric transfer back to the awaiting coroutine.
-     */
-    struct promise_type
-    {
-        // Captured exception from the coroutine body, rethrown in
-        // await_resume() when this task is co_await-ed by a caller.
-        std::exception_ptr exception_;
-
-        // Handle to the coroutine that is co_await-ing this task.
-        // Set by await_suspend(). FinalAwaiter uses it for symmetric
-        // transfer back to the caller. Null if this is a top-level task.
-        std::coroutine_handle<> continuation_;
-
-        /**
-         * Create the CoroTask return object.
-         * Called by the compiler at coroutine creation.
-         */
-        CoroTask
-        get_return_object()
-        {
-            return CoroTask{Handle::from_promise(*this)};
-        }
-
-        /**
-         * Lazy start. The coroutine body does not execute until the
-         * handle is explicitly resumed (e.g. by CoroTaskRunner::resume).
-         */
-        std::suspend_always
-        initial_suspend() noexcept
-        {
-            return {};
-        }
-
-        /**
-         * Awaiter returned by final_suspend(). Uses symmetric transfer:
-         * if a continuation exists, transfers control directly to it
-         * (tail-call, no stack growth). Otherwise returns noop_coroutine
-         * so the coroutine frame stays alive for the owner to destroy.
-         */
-        struct FinalAwaiter
-        {
-            /**
-             * Always false. We need await_suspend to run for
-             * symmetric transfer.
-             */
-            bool
-            await_ready() noexcept
-            {
-                return false;
-            }
-
-            /**
-             * Symmetric transfer: returns the continuation handle so
-             * the compiler emits a tail-call instead of a nested resume.
-             * If no continuation is set, returns noop_coroutine to
-             * suspend at final_suspend without destroying the frame.
-             *
-             * @param h Handle to this completing coroutine
-             *
-             * @return Continuation handle, or noop_coroutine
-             */
-            std::coroutine_handle<>
-            await_suspend(Handle h) noexcept
-            {
-                if (auto cont = h.promise().continuation_)
-                    return cont;
-                return std::noop_coroutine();
-            }
-
-            void
-            await_resume() noexcept
-            {
-            }
-        };
-
-        /**
-         * Returns FinalAwaiter for symmetric transfer at coroutine end.
-         */
-        FinalAwaiter
-        final_suspend() noexcept
-        {
-            return {};
-        }
-
-        /**
-         * Called by the compiler for `co_return;` (void coroutine).
-         */
-        void
-        return_void()
-        {
-        }
-
-        /**
-         * Called by the compiler when an exception escapes the coroutine
-         * body. Captures it for later rethrowing in await_resume().
-         */
-        void
-        unhandled_exception()
-        {
-            exception_ = std::current_exception();
-        }
-    };
-
-    /**
-     * Default constructor. Creates an empty (null handle) task.
-     */
-    CoroTask() = default;
-
-    /**
-     * Takes ownership of a compiler-generated coroutine handle.
-     *
-     * @param h Coroutine handle to own
-     */
-    explicit CoroTask(Handle h) : handle_(h)
-    {
-    }
-
-    /**
-     * Destroys the coroutine frame if this task owns one.
-     */
-    ~CoroTask()
-    {
-        if (handle_)
-            handle_.destroy();
-    }
-
-    /**
-     * Move constructor. Transfers handle ownership, leaves other empty.
-     */
-    CoroTask(CoroTask&& other) noexcept : handle_(std::exchange(other.handle_, {}))
-    {
-    }
-
-    /**
-     * Move assignment. Destroys current frame (if any), takes other's.
-     */
-    CoroTask&
-    operator=(CoroTask&& other) noexcept
-    {
-        if (this != &other)
-        {
-            if (handle_)
-                handle_.destroy();
-            handle_ = std::exchange(other.handle_, {});
-        }
-        return *this;
-    }
-
-    CoroTask(CoroTask const&) = delete;
-    CoroTask&
-    operator=(CoroTask const&) = delete;
-
-    /**
-     * @return The underlying coroutine_handle
-     */
-    Handle
-    handle() const
-    {
-        return handle_;
-    }
-
-    /**
-     * @return true if the coroutine has run to completion (or thrown)
-     */
-    bool
-    done() const
-    {
-        return handle_ && handle_.done();
-    }
-
-    // -- Awaiter interface: allows `co_await someCoroTask;` --
-
-    /**
-     * Always false. This task is lazy, so co_await always suspends
-     * the caller to set up the continuation link.
-     */
-    bool
-    await_ready() const noexcept
-    {
-        return false;
-    }
-
-    /**
-     * Stores the caller's handle as our continuation, then returns
-     * our handle for symmetric transfer (caller suspends, we resume).
-     *
-     * @param caller Handle of the coroutine doing co_await on us
-     *
-     * @return Our handle for symmetric transfer
-     */
-    std::coroutine_handle<>
-    await_suspend(std::coroutine_handle<> caller) noexcept
-    {
-        XRPL_ASSERT(handle_, "xrpl::CoroTask<void>::await_suspend : handle is valid");
-        handle_.promise().continuation_ = caller;
-        return handle_;  // Symmetric transfer
-    }
-
-    /**
-     * Called in the awaiting coroutine's context after this task
-     * completes. Rethrows any exception captured by
-     * unhandled_exception().
-     */
-    void
-    await_resume()
-    {
-        XRPL_ASSERT(handle_, "xrpl::CoroTask<void>::await_resume : handle is valid");
-        if (auto& ep = handle_.promise().exception_)
-            std::rethrow_exception(ep);
-    }
-
-private:
-    // Exclusively-owned coroutine handle. Null after move or default
-    // construction. Destroyed in the destructor.
-    Handle handle_;
-};
-
-/**
- * CoroTask<T> -- coroutine return type for value-returning coroutines.
- *
- * Class / Dependency Diagram
- * ==========================
- *
- *   CoroTask<T>
- *   +-----------------------------------------------+
- *   | - handle_ : Handle (coroutine_handle<promise>) |
- *   +-----------------------------------------------+
- *   | + handle(), done()                             |
- *   | + await_ready/suspend/resume  (Awaiter iface)  |
- *   +-----------------------------------------------+
- *            |  owns
- *            v
- *   promise_type
- *   +-----------------------------------------------+
- *   | - result_       : variant<monostate, T,        |
- *   |                           exception_ptr>       |
- *   | - continuation_ : std::coroutine_handle<>      |
- *   +-----------------------------------------------+
- *   | + get_return_object() -> CoroTask              |
- *   | + initial_suspend()   -> suspend_always (lazy) |
- *   | + final_suspend()     -> FinalAwaiter          |
- *   | + return_value(T)     -> stores in result_[1]  |
- *   | + unhandled_exception -> stores in result_[2]  |
- *   +-----------------------------------------------+
- *            |  returns at final_suspend
- *            v
- *   FinalAwaiter  (same symmetric-transfer pattern as CoroTask<void>)
- *
- * Value Extraction
- * ----------------
- * await_resume() inspects the variant:
- *   - index 2 (exception_ptr) -> rethrow
- *   - index 1 (T)             -> return value via move
- *
- * Usage Examples
- * ==============
- *
- * 1. Simple value return:
- *
- *      CoroTask<int> computeAnswer() { co_return 42; }
- *
- *      CoroTask<void> caller() {
- *          int v = co_await computeAnswer();  // v == 42
- *      }
- *
- * 2. Chaining value-returning coroutines:
- *
- *      CoroTask<int> add(int a, int b) { co_return a + b; }
- *      CoroTask<int> doubleSum(int a, int b) {
- *          int s = co_await add(a, b);
- *          co_return s * 2;
- *      }
- *
- * 3. Exception propagation from inner to outer:
- *
- *      CoroTask<int> failing() {
- *          throw std::runtime_error("bad");
- *          co_return 0;  // never reached
- *      }
- *      CoroTask<void> caller() {
- *          try {
- *              int v = co_await failing();  // throws here
- *          } catch (std::runtime_error const& e) {
- *              // e.what() == "bad"
- *          }
- *      }
- *
- * Caveats / Pitfalls (in addition to CoroTask<void> caveats above)
- * ================================================================
- *
- * BUG-RISK: await_resume() moves the value out of the variant.
- *   Calling co_await on the same CoroTask<T> instance twice is undefined
- *   behavior -- the second call will see a moved-from T. CoroTask is
- *   single-shot: one co_return, one co_await.
- *
- * BUG-RISK: T must be move-constructible.
- *   return_value(T) takes by value and moves into the variant.
- *   Types that are not movable cannot be used as T.
- *
- * LIMITATION: No co_yield support.
- *   CoroTask<T> only supports a single co_return. It does not implement
- *   yield_value(), so using co_yield inside a CoroTask<T> coroutine is a
- *   compile error. For streaming values, a different return type
- *   (e.g. Generator<T>) would be needed.
- *
- * LIMITATION: Result is only accessible via co_await.
- *   There is no .get() or .result() method. The value can only be
- *   extracted by co_await-ing the CoroTask<T> from inside another
- *   coroutine. For extracting results in non-coroutine code, pass a
- *   pointer to the caller and write through it (as the tests do).
- */
-template <typename T>
-class CoroTask
-{
-    static_assert(
-        std::is_move_constructible_v<T>,
-        "CoroTask<T> requires T to be move-constructible");
-
-public:
-    struct promise_type;
-    using Handle = std::coroutine_handle<promise_type>;
-
-    /**
-     * Coroutine promise for value-returning coroutines.
-     * Stores the result as a variant: monostate (not yet set),
-     * T (co_return value), or exception_ptr (unhandled exception).
-     */
-    struct promise_type
-    {
-        // Tri-state result:
-        //   index 0 (monostate) -- coroutine has not yet completed
-        //   index 1 (T)         -- co_return value stored here
-        //   index 2 (exception) -- unhandled exception captured here
-        std::variant<std::monostate, T, std::exception_ptr> result_;
-
-        // Handle to the coroutine co_await-ing this task. Used by
-        // FinalAwaiter for symmetric transfer. Null for top-level tasks.
-        std::coroutine_handle<> continuation_;
-
-        /**
-         * Create the CoroTask return object.
-         * Called by the compiler at coroutine creation.
-         */
-        CoroTask
-        get_return_object()
-        {
-            return CoroTask{Handle::from_promise(*this)};
-        }
-
-        /**
-         * Lazy start. Coroutine body does not run until explicitly resumed.
-         */
-        std::suspend_always
-        initial_suspend() noexcept
-        {
-            return {};
-        }
-
-        /**
-         * Symmetric-transfer awaiter at coroutine completion.
-         * Same pattern as CoroTask<void>::FinalAwaiter.
-         */
-        struct FinalAwaiter
-        {
-            bool
-            await_ready() noexcept
-            {
-                return false;
-            }
-
-            /**
-             * Returns continuation for symmetric transfer, or
-             * noop_coroutine if this is a top-level task.
-             *
-             * @param h Handle to this completing coroutine
-             *
-             * @return Continuation handle, or noop_coroutine
-             */
-            std::coroutine_handle<>
-            await_suspend(Handle h) noexcept
-            {
-                if (auto cont = h.promise().continuation_)
-                    return cont;
-                return std::noop_coroutine();
-            }
-
-            void
-            await_resume() noexcept
-            {
-            }
-        };
-
-        FinalAwaiter
-        final_suspend() noexcept
-        {
-            return {};
-        }
-
-        /**
-         * Called by the compiler for `co_return value;`.
-         * Moves the value into result_ at index 1.
-         *
-         * @param value The value to store
-         */
-        void
-        return_value(T value)
-        {
-            result_.template emplace<1>(std::move(value));
-        }
-
-        /**
-         * Captures unhandled exceptions at index 2 of result_.
-         * Rethrown later in await_resume().
-         */
-        void
-        unhandled_exception()
-        {
-            result_.template emplace<2>(std::current_exception());
-        }
-    };
-
-    /**
-     * Default constructor. Creates an empty (null handle) task.
-     */
-    CoroTask() = default;
-
-    /**
-     * Takes ownership of a compiler-generated coroutine handle.
-     *
-     * @param h Coroutine handle to own
-     */
-    explicit CoroTask(Handle h) : handle_(h)
-    {
-    }
-
-    /**
-     * Destroys the coroutine frame if this task owns one.
-     */
-    ~CoroTask()
-    {
-        if (handle_)
-            handle_.destroy();
-    }
-
-    /**
-     * Move constructor. Transfers handle ownership, leaves other empty.
-     */
-    CoroTask(CoroTask&& other) noexcept : handle_(std::exchange(other.handle_, {}))
-    {
-    }
-
-    /**
-     * Move assignment. Destroys current frame (if any), takes other's.
-     */
-    CoroTask&
-    operator=(CoroTask&& other) noexcept
-    {
-        if (this != &other)
-        {
-            if (handle_)
-                handle_.destroy();
-            handle_ = std::exchange(other.handle_, {});
-        }
-        return *this;
-    }
-
-    CoroTask(CoroTask const&) = delete;
-    CoroTask&
-    operator=(CoroTask const&) = delete;
-
-    /**
-     * @return The underlying coroutine_handle
-     */
-    Handle
-    handle() const
-    {
-        return handle_;
-    }
-
-    /**
-     * @return true if the coroutine has run to completion (or thrown)
-     */
-    bool
-    done() const
-    {
-        return handle_ && handle_.done();
-    }
-
-    // -- Awaiter interface: allows `T val = co_await someCoroTask;` --
-
-    /**
-     * Always false. co_await always suspends to set up continuation.
-     */
-    bool
-    await_ready() const noexcept
-    {
-        return false;
-    }
-
-    /**
-     * Stores caller as continuation, returns our handle for
-     * symmetric transfer.
-     *
-     * @param caller Handle of the coroutine doing co_await on us
-     *
-     * @return Our handle for symmetric transfer
-     */
-    std::coroutine_handle<>
-    await_suspend(std::coroutine_handle<> caller) noexcept
-    {
-        XRPL_ASSERT(handle_, "xrpl::CoroTask<T>::await_suspend : handle is valid");
-        handle_.promise().continuation_ = caller;
-        return handle_;
-    }
-
-    /**
-     * Extracts the result: rethrows if exception, otherwise moves
-     * the T value out of the variant. Single-shot: calling twice
-     * on the same task is undefined (moved-from T).
-     *
-     * @return The co_return-ed value
-     */
-    T
-    await_resume()
-    {
-        XRPL_ASSERT(handle_, "xrpl::CoroTask<T>::await_resume : handle is valid");
-        auto& result = handle_.promise().result_;
-        if (auto* ep = std::get_if<2>(&result))
-            std::rethrow_exception(*ep);
-        return std::get<1>(std::move(result));
-    }
-
-private:
-    // Exclusively-owned coroutine handle. Null after move or default
-    // construction. Destroyed in the destructor.
-    Handle handle_;
-};
-
-}  // namespace xrpl

include/xrpl/core/CoroTaskRunner.ipp

@@ -1,378 +0,0 @@
-#pragma once
-
-/**
- * @file CoroTaskRunner.ipp
- *
- * CoroTaskRunner inline implementation.
- *
- * This file contains the business logic for managing C++20 coroutines
- * on the JobQueue. It is included at the bottom of JobQueue.h.
- *
- * Data Flow: suspend / post / resume cycle
- * =========================================
- *
- *         coroutine body                 CoroTaskRunner              JobQueue
- *         --------------                 --------------              --------
- *              |
- *    co_await runner->suspend()
- *              |
- *              +--- await_suspend ------> onSuspend()
- *              |                            ++nSuspend_ ------------> nSuspend_
- *              |                          [coroutine is now suspended]
- *              |
- *              .    (externally or by yieldAndPost())
- *              .
- *              +--- (caller calls) -----> post()
- *              |                            ++runCount_
- *              |                            addJob(resume) ----------> job enqueued
- *              |                                                        |
- *              |                                                      [worker picks up]
- *              |                                                        |
- *              +--- <----- resume() <-----------------------------------+
- *              |             --nSuspend_ ------> nSuspend_
- *              |             swap in LocalValues (lvs_)
- *              |             task_.handle().resume()
- *              |                |
- *              |    [coroutine body continues here]
- *              |                |
- *              |             swap out LocalValues
- *              |             --runCount_
- *              |             cv_.notify_all()
- *              v
- *
- * Thread Safety
- * =============
- * - mutex_     : guards task_.handle().resume() so that post()-before-suspend
- *                races cannot resume the coroutine while it is still running.
- *                (See the race condition discussion in JobQueue.h)
- * - mutex_run_ : guards runCount_ counter; used by join() to wait until
- *                all in-flight resume operations complete.
- * - jq_.m_mutex: guards nSuspend_ increments/decrements.
- *
- * Common Mistakes When Modifying This File
- * =========================================
- *
- * 1. Changing lock ordering.
- *    resume() acquires locks sequentially (never held simultaneously):
- *    jq_.m_mutex (released immediately), then mutex_ (held across resume),
- *    then mutex_run_ (released after decrement). post() acquires only
- *    mutex_run_. Any new code path must follow the same order.
- *
- * 2. Removing the shared_from_this() capture in post().
- *    The lambda passed to addJob captures [this, sp = shared_from_this()].
- *    If you remove sp, 'this' can be destroyed before the job runs,
- *    causing use-after-free. The sp capture is load-bearing.
- *
- * 3. Forgetting to decrement nSuspend_ on a new code path.
- *    Every ++nSuspend_ must have a matching --nSuspend_. If you add a new
- *    suspension path (e.g. a new awaiter) and forget to decrement on resume
- *    or on failure, JobQueue::stop() will hang.
- *
- * 4. Calling task_.handle().resume() without holding mutex_.
- *    This allows a race where the coroutine runs on two threads
- *    simultaneously. Always hold mutex_ around resume().
- *
- * 5. Swapping LocalValues outside of the mutex_ critical section.
- *    The swap-in and swap-out of LocalValues must bracket the resume()
- *    call. If you move the swap-out before the lock_guard(mutex_) is
- *    released, you break LocalValue isolation for any code that runs
- *    after the coroutine suspends but before the lock is dropped.
- */
-
-namespace xrpl {
-
-/**
- * Construct a CoroTaskRunner. Sets runCount_ to 0; does not
- * create the coroutine. Call init() afterwards.
- *
- * @param jq   The JobQueue this coroutine will run on
- * @param type Job type for scheduling priority
- * @param name Human-readable name for logging
- */
-inline JobQueue::CoroTaskRunner::CoroTaskRunner(
-    create_t,
-    JobQueue& jq,
-    JobType type,
-    std::string const& name)
-    : jq_(jq), type_(type), name_(name), runCount_(0)
-{
-}
-
-/**
- * Initialize with a coroutine-returning callable.
- * Stores the callable on the heap (FuncStore) so it outlives the
- * coroutine frame. Coroutine frames store a reference to the
- * callable's implicit object parameter (the lambda). If the callable
- * is a temporary, that reference dangles after the caller returns.
- * Keeping the callable alive here ensures the coroutine's captures
- * remain valid.
- *
- * @param f Callable: CoroTask<void>(shared_ptr<CoroTaskRunner>)
- */
-template <class F>
-void
-JobQueue::CoroTaskRunner::init(F&& f)
-{
-    using Fn = std::decay_t<F>;
-    auto store = std::make_unique<FuncStore<Fn>>(std::forward<F>(f));
-    task_ = store->func(shared_from_this());
-    storedFunc_ = std::move(store);
-}
-
-/**
- * Destructor. Waits for any in-flight resume() to complete, then
- * asserts (debug) that the coroutine has finished or
- * expectEarlyExit() was called.
- *
- * The join() call is necessary because with async dispatch the
- * coroutine runs on a worker thread. The gate signal (which wakes
- * the test thread) can arrive before resume() has set finished_.
- * join() synchronizes via mutex_run_, establishing a happens-before
- * edge: finished_ = true -> unlock(mutex_run_) in resume() ->
- * lock(mutex_run_) in join() -> read finished_.
- */
-inline JobQueue::CoroTaskRunner::~CoroTaskRunner()
-{
-#ifndef NDEBUG
-    join();
-    XRPL_ASSERT(
-        finished_.load(std::memory_order_acquire),
-        "xrpl::JobQueue::CoroTaskRunner::~CoroTaskRunner : is finished");
-#endif
-}
-
-/**
- * Increment the JobQueue's suspended-coroutine count (nSuspend_).
- */
-inline void
-JobQueue::CoroTaskRunner::onSuspend()
-{
-    std::lock_guard lock(jq_.m_mutex);
-    ++jq_.nSuspend_;
-}
-
-/**
- * Decrement nSuspend_ without resuming.
- */
-inline void
-JobQueue::CoroTaskRunner::onUndoSuspend()
-{
-    std::lock_guard lock(jq_.m_mutex);
-    --jq_.nSuspend_;
-}
-
-/**
- * Return a SuspendAwaiter whose await_suspend() increments nSuspend_
- * before the coroutine actually suspends. The caller must later call
- * post() or resume() to continue execution.
- *
- * @return Awaiter for use with `co_await runner->suspend()`
- */
-inline auto
-JobQueue::CoroTaskRunner::suspend()
-{
-    /**
-     * Custom awaiter for suspend(). Always suspends (await_ready
-     * returns false) and increments nSuspend_ in await_suspend().
-     */
-    struct SuspendAwaiter
-    {
-        CoroTaskRunner& runner_;  // The runner that owns this coroutine.
-
-        /**
-         * Always returns false so the coroutine suspends.
-         */
-        bool
-        await_ready() const noexcept
-        {
-            return false;
-        }
-
-        /**
-         * Called when the coroutine suspends. Increments nSuspend_
-         * so the JobQueue knows a coroutine is waiting.
-         */
-        void
-        await_suspend(std::coroutine_handle<>) const
-        {
-            runner_.onSuspend();
-        }
-
-        void
-        await_resume() const noexcept
-        {
-        }
-    };
-    return SuspendAwaiter{*this};
-}
-
-/**
- * Suspend and immediately repost on the JobQueue. Equivalent to
- * `co_await JobQueueAwaiter{runner}` but uses an inline struct
- * to work around a GCC-12 codegen bug (see declaration in JobQueue.h).
- *
- * If the JobQueue is stopping (post fails), the suspend count is
- * undone and the coroutine is resumed immediately via h.resume().
- *
- * @return An inline YieldPostAwaiter
- */
-inline auto
-JobQueue::CoroTaskRunner::yieldAndPost()
-{
-    struct YieldPostAwaiter
-    {
-        CoroTaskRunner& runner_;
-
-        bool
-        await_ready() const noexcept
-        {
-            return false;
-        }
-
-        void
-        await_suspend(std::coroutine_handle<> h)
-        {
-            runner_.onSuspend();
-            if (!runner_.post())
-            {
-                runner_.onUndoSuspend();
-                h.resume();
-            }
-        }
-
-        void
-        await_resume() const noexcept
-        {
-        }
-    };
-    return YieldPostAwaiter{*this};
-}
-
-/**
- * Schedule coroutine resumption as a job on the JobQueue.
- * A shared_ptr capture (sp) prevents this CoroTaskRunner from being
- * destroyed while the job is queued but not yet executed.
- *
- * @return false if the JobQueue rejected the job (shutting down)
- */
-inline bool
-JobQueue::CoroTaskRunner::post()
-{
-    {
-        std::lock_guard lk(mutex_run_);
-        ++runCount_;
-    }
-
-    // sp prevents 'this' from being destroyed while the job is pending
-    if (jq_.addJob(type_, name_, [this, sp = shared_from_this()]() { resume(); }))
-    {
-        return true;
-    }
-
-    // The coroutine will not run. Undo the runCount_ increment.
-    std::lock_guard lk(mutex_run_);
-    --runCount_;
-    cv_.notify_all();
-    return false;
-}
-
-/**
- * Resume the coroutine on the current thread.
- *
- * Steps:
- *   1. Decrement nSuspend_ (under jq_.m_mutex)
- *   2. Swap in this coroutine's LocalValues for thread-local isolation
- *   3. Resume the coroutine handle (under mutex_)
- *   4. Swap out LocalValues, restoring the thread's previous state
- *   5. Decrement runCount_ and notify join() waiters
- *
- * @pre post() must have been called before resume(). Direct calls
- *      without a prior post() will corrupt runCount_ and break join().
- * Note: runCount_ is NOT incremented here — post() already did that.
- * This ensures join() stays blocked for the entire post->resume lifetime.
- */
-inline void
-JobQueue::CoroTaskRunner::resume()
-{
-    {
-        std::lock_guard lock(jq_.m_mutex);
-        --jq_.nSuspend_;
-    }
-    auto saved = detail::getLocalValues().release();
-    detail::getLocalValues().reset(&lvs_);
-    std::lock_guard lock(mutex_);
-    XRPL_ASSERT(
-        task_.handle() && !task_.done(),
-        "xrpl::JobQueue::CoroTaskRunner::resume : task handle is valid and not done");
-    task_.handle().resume();
-    detail::getLocalValues().release();
-    detail::getLocalValues().reset(saved);
-    if (task_.done())
-    {
-        finished_.store(true, std::memory_order_release);
-        // Break the shared_ptr cycle: frame -> shared_ptr<runner> -> this.
-        // Use std::move (not task_ = {}) so task_.handle_ is null BEFORE the
-        // frame is destroyed. operator= would destroy the frame while handle_
-        // still holds the old value -- a re-entrancy hazard on GCC-12 if
-        // frame destruction triggers runner cleanup.
-        [[maybe_unused]] auto completed = std::move(task_);
-    }
-    std::lock_guard lk(mutex_run_);
-    --runCount_;
-    cv_.notify_all();
-}
-
-/**
- * @return true if the coroutine has not yet run to completion.
- *
- * Uses the atomic finished_ flag instead of reading task_ directly,
- * because task_ is modified in resume() under mutex_ and reading it
- * here without a lock would be a data race visible to TSAN.
- */
-inline bool
-JobQueue::CoroTaskRunner::runnable() const
-{
-    return !finished_.load(std::memory_order_acquire);
-}
-
-/**
- * Handle early termination when the coroutine never ran (e.g. JobQueue
- * is stopping). Decrements nSuspend_ and destroys the coroutine frame
- * to break the shared_ptr cycle: frame -> lambda -> runner -> frame.
- */
-inline void
-JobQueue::CoroTaskRunner::expectEarlyExit()
-{
-    if (!finished_.load(std::memory_order_acquire))
-    {
-        std::lock_guard lock(jq_.m_mutex);
-        --jq_.nSuspend_;
-        finished_.store(true, std::memory_order_release);
-    }
-    // Break the shared_ptr cycle: frame -> shared_ptr<runner> -> this.
-    // The coroutine is at initial_suspend and never ran user code, so
-    // destroying it is safe. Use std::move (not task_ = {}) so
-    // task_.handle_ is null before the frame is destroyed.
-    {
-        [[maybe_unused]] auto completed = std::move(task_);
-    }
-    storedFunc_.reset();
-}
-
-/**
- * Block until all pending/active resume operations complete.
- * Uses cv_ + mutex_run_ to wait until runCount_ reaches 0 or
- * finished_ becomes true. The finished_ check handles the case
- * where resume() is called directly (without post()), which
- * decrements runCount_ below zero. In that scenario runCount_
- * never returns to 0, but finished_ becoming true guarantees
- * the coroutine is done and no more resumes will occur.
- */
-inline void
-JobQueue::CoroTaskRunner::join()
-{
-    std::unique_lock<std::mutex> lk(mutex_run_);
-    cv_.wait(lk, [this]() { return runCount_ == 0 || finished_.load(std::memory_order_acquire); });
-}
-
-}  // namespace xrpl

include/xrpl/core/JobQueue.h

@@ -2,22 +2,27 @@
 
 #include <xrpl/basics/LocalValue.h>
 #include <xrpl/core/ClosureCounter.h>
-#include <xrpl/core/CoroTask.h>
 #include <xrpl/core/JobTypeData.h>
 #include <xrpl/core/JobTypes.h>
 #include <xrpl/core/detail/Workers.h>
 #include <xrpl/json/json_value.h>
 
-#include <coroutine>
+#include <boost/context/protected_fixedsize_stack.hpp>
+#include <boost/coroutine2/all.hpp>
+
 #include <set>
 
 namespace xrpl {
 
 namespace perf {
 class PerfLog;
-}
+}  // namespace perf
 
 class Logs;
+struct Coro_create_t
+{
+    explicit Coro_create_t() = default;
+};
 
 /** A pool of threads to perform work.
 
@@ -32,418 +37,85 @@ class Logs;
 class JobQueue : private Workers::Callback
 {
 public:
-    /** C++20 coroutine lifecycle manager.
-     *
-     *  Class / Inheritance / Dependency Diagram
-     *  =========================================
-     *
-     *  std::enable_shared_from_this<CoroTaskRunner>
-     *            ^
-     *            | (public inheritance)
-     *            |
-     *  CoroTaskRunner
-     *  +---------------------------------------------------+
-     *  | - lvs_         : detail::LocalValues               |
-     *  | - jq_          : JobQueue&                         |
-     *  | - type_        : JobType                           |
-     *  | - name_        : std::string                       |
-     *  | - runCount_    : int         (in-flight resumes)    |
-     *  | - mutex_       : std::mutex      (coroutine guard) |
-     *  | - mutex_run_   : std::mutex      (join guard)      |
-     *  | - cv_          : condition_variable                 |
-     *  | - task_        : CoroTask<void>                    |
-     *  | - storedFunc_  : unique_ptr<FuncBase> (type-erased)|
-     *  +---------------------------------------------------+
-     *  | + init(F&&)         : set up coroutine callable    |
-     *  | + onSuspend()       : ++jq_.nSuspend_              |
-     *  | + onUndoSuspend()   : --jq_.nSuspend_              |
-     *  | + suspend()         : returns SuspendAwaiter       |
-     *  | + post()            : schedule resume on JobQueue  |
-     *  | + resume()          : resume coroutine on caller   |
-     *  | + runnable()        : !task_.done()                |
-     *  | + expectEarlyExit() : teardown for failed post     |
-     *  | + join()            : block until not running       |
-     *  +---------------------------------------------------+
-     *          |                          |
-     *          | owns                     | references
-     *          v                          v
-     *    CoroTask<void>             JobQueue
-     *    (coroutine frame)          (thread pool + nSuspend_)
-     *
-     *    FuncBase / FuncStore<F>    (type-erased heap storage
-     *                                for the coroutine lambda)
-     *
-     *  Coroutine Lifecycle (Control Flow)
-     *  ===================================
-     *
-     *  Caller thread              JobQueue worker thread
-     *  -------------              ----------------------
-     *  postCoroTask(f)
-     *    |
-     *    +-- check stopping_ (reject if JQ shutting down)
-     *    +-- ++nSuspend_  (lazy start counts as suspended)
-     *    +-- make_shared<CoroTaskRunner>
-     *    +-- init(f)
-     *    |     +-- store lambda on heap (FuncStore)
-     *    |     +-- task_ = f(shared_from_this())
-     *    |           [coroutine created, suspended at initial_suspend]
-     *    +-- post()
-     *    |     +-- ++runCount_
-     *    |     +-- addJob(type_, [resume]{})
-     *    |                                    resume()
-     *    |                                      |
-     *    |                                      +-- --nSuspend_
-     *    |                                      +-- swap in LocalValues
-     *    |                                      +-- task_.handle().resume()
-     *    |                                      |     [coroutine body runs]
-     *    |                                      |     ...
-     *    |                                      |     co_await suspend()
-     *    |                                      |       +-- ++nSuspend_
-     *    |                                      |       [coroutine suspends]
-     *    |                                      +-- swap out LocalValues
-     *    |                                      +-- --runCount_
-     *    |                                      +-- cv_.notify_all()
-     *    |
-     *  post()  <-- called externally or by yieldAndPost()
-     *    +-- ++runCount_
-     *    +-- addJob(type_, [resume]{})
-     *                                         resume()
-     *                                           |
-     *                                           +-- [coroutine body continues]
-     *                                           +-- co_return
-     *                                           +-- --runCount_
-     *                                           +-- cv_.notify_all()
-     *  join()
-     *    +-- cv_.wait([]{runCount_ == 0})
-     *    +-- [done]
-     *
-     *  Usage Examples
-     *  ==============
-     *
-     *  1. Fire-and-forget coroutine (most common pattern):
-     *
-     *      jq.postCoroTask(jtCLIENT, "MyWork",
-     *          [](auto runner) -> CoroTask<void> {
-     *              doSomeWork();
-     *              co_await runner->suspend();  // yield to other jobs
-     *              doMoreWork();
-     *              co_return;
-     *          });
-     *
-     *  2. Manually controlling suspend / resume (external trigger):
-     *
-     *      auto runner = jq.postCoroTask(jtCLIENT, "ExtTrigger",
-     *          [&result](auto runner) -> CoroTask<void> {
-     *              startAsyncOperation(callback);
-     *              co_await runner->suspend();
-     *              // callback called runner->post() to get here
-     *              result = collectResult();
-     *              co_return;
-     *          });
-     *      // ... later, from the callback:
-     *      runner->post();   // reschedule the coroutine on the JobQueue
-     *
-     *  3. Using yieldAndPost() for automatic suspend + repost:
-     *
-     *      jq.postCoroTask(jtCLIENT, "AutoRepost",
-     *          [](auto runner) -> CoroTask<void> {
-     *              step1();
-     *              co_await runner->yieldAndPost();  // yield + auto-repost
-     *              step2();
-     *              co_await runner->yieldAndPost();
-     *              step3();
-     *              co_return;
-     *          });
-     *
-     *  4. Checking shutdown after co_await (cooperative cancellation):
-     *
-     *      jq.postCoroTask(jtCLIENT, "Cancellable",
-     *          [&jq](auto runner) -> CoroTask<void> {
-     *              while (moreWork()) {
-     *                  co_await runner->yieldAndPost();
-     *                  if (jq.isStopping())
-     *                      co_return;  // bail out cleanly
-     *                  processNextItem();
-     *              }
-     *              co_return;
-     *          });
-     *
-     *  Caveats / Pitfalls
-     *  ==================
-     *
-     *  BUG-RISK: Calling suspend() without a matching post()/resume().
-     *    After co_await runner->suspend(), the coroutine is parked and
-     *    nSuspend_ is incremented.  If nothing ever calls post() or
-     *    resume(), the coroutine is leaked and JobQueue::stop() will
-     *    hang forever waiting for nSuspend_ to reach zero.
-     *
-     *  BUG-RISK: Calling post() on an already-running coroutine.
-     *    post() schedules a resume() job.  If the coroutine has not
-     *    actually suspended yet (no co_await executed), the resume job
-     *    will try to call handle().resume() while the coroutine is still
-     *    running on another thread.  This is UB.  The mutex_ prevents
-     *    data corruption but the logic is wrong — always co_await
-     *    suspend() before calling post().  (The test incorrect_order()
-     *    shows this works only because mutex_ serializes the calls.)
-     *
-     *  BUG-RISK: Dropping the shared_ptr<CoroTaskRunner> before join().
-     *    The CoroTaskRunner destructor asserts that finished_ is true
-     *    (the coroutine completed). If you let the last shared_ptr die
-     *    while the coroutine is still running or suspended, you get an
-     *    assertion failure in debug and UB in release.  Always call
-     *    join() or expectEarlyExit() first.
-     *
-     *  BUG-RISK: Lambda captures outliving the coroutine frame.
-     *    The lambda passed to postCoroTask is heap-allocated (FuncStore)
-     *    to prevent dangling.  But objects captured by pointer still need
-     *    their own lifetime management.  If you capture a raw pointer to
-     *    a stack variable, and the stack frame exits before the coroutine
-     *    finishes, the pointer dangles.  Use shared_ptr or ensure the
-     *    pointed-to object outlives the coroutine.
-     *
-     *  BUG-RISK: Forgetting co_return in a void coroutine.
-     *    If the coroutine body falls off the end without co_return,
-     *    the compiler may silently treat it as co_return (per standard),
-     *    but some compilers warn.  Always write explicit co_return.
-     *
-     *  LIMITATION: CoroTaskRunner only supports CoroTask<void>.
-     *    The task_ member is CoroTask<void>.  To return values from
-     *    the top-level coroutine, write through a captured pointer
-     *    (as the tests demonstrate), or co_await inner CoroTask<T>
-     *    coroutines that return values.
-     *
-     *  LIMITATION: One coroutine per CoroTaskRunner.
-     *    init() must be called exactly once.  You cannot reuse a
-     *    CoroTaskRunner to run a second coroutine.  Create a new one
-     *    via postCoroTask() instead.
-     *
-     *  LIMITATION: No timeout on join().
-     *    join() blocks indefinitely.  If the coroutine is suspended
-     *    and never posted, join() will deadlock.  Use timed waits
-     *    on the gate pattern (condition_variable + wait_for) in tests.
-     */
-    class CoroTaskRunner : public std::enable_shared_from_this<CoroTaskRunner>
+    /** Coroutines must run to completion. */
+    class Coro : public std::enable_shared_from_this<Coro>
     {
     private:
-        // Per-coroutine thread-local storage. Swapped in before resume()
-        // and swapped out after, so each coroutine sees its own LocalValue
-        // state regardless of which worker thread executes it.
         detail::LocalValues lvs_;
-
-        // Back-reference to the owning JobQueue. Used to post jobs,
-        // increment/decrement nSuspend_, and acquire jq_.m_mutex.
         JobQueue& jq_;
-
-        // Job type passed to addJob() when posting this coroutine.
         JobType type_;
-
-        // Human-readable name for this coroutine job (for logging).
         std::string name_;
-
-        // Number of in-flight resume operations (pending + active).
-        // Incremented by post(), decremented when resume() finishes.
-        // Guarded by mutex_run_. join() blocks until this reaches 0.
-        //
-        // A counter (not a bool) is needed because post() can be called
-        // from within the coroutine body (e.g. via yieldAndPost()),
-        // enqueuing a second resume while the first is still running.
-        // A bool would be clobbered: R2.post() sets true, then R1's
-        // cleanup sets false — losing the fact that R2 is still pending.
-        int runCount_;
-
-        // Serializes all coroutine resume() calls, preventing concurrent
-        // execution of the coroutine body on multiple threads. Handles the
-        // race where post() enqueues a resume before the coroutine has
-        // actually suspended (post-before-suspend pattern).
+        bool running_{false};
         std::mutex mutex_;
-
-        // Guards runCount_. Used with cv_ for join() to wait
-        // until all pending/active resume operations complete.
         std::mutex mutex_run_;
-
-        // Notified when runCount_ reaches zero, allowing
-        // join() waiters to wake up.
         std::condition_variable cv_;
-
-        // The coroutine handle wrapper. Owns the coroutine frame.
-        // Set by init(). Reset to empty in resume() upon coroutine
-        // completion (to break the shared_ptr cycle) or in
-        // expectEarlyExit() on early termination.
-        CoroTask<void> task_;
-
-        /**
-         * Type-erased base for heap-stored callables.
-         * Prevents the coroutine lambda from being destroyed before
-         * the coroutine frame is done with it.
-         *
-         * @see FuncStore
-         */
-        struct FuncBase
-        {
-            virtual ~FuncBase() = default;
-        };
-
-        /**
-         * Concrete type-erased storage for a callable of type F.
-         * The coroutine frame stores a reference to the lambda's implicit
-         * object parameter. If the lambda is a temporary, that reference
-         * dangles after the call returns. FuncStore keeps it alive on
-         * the heap for the lifetime of the CoroTaskRunner.
-         */
-        template <class F>
-        struct FuncStore : FuncBase
-        {
-            F func;  // The stored callable (coroutine lambda).
-            explicit FuncStore(F&& f) : func(std::move(f))
-            {
-            }
-        };
-
-        // Heap-allocated callable storage. Set by init(), ensures the
-        // lambda outlives the coroutine frame that references it.
-        std::unique_ptr<FuncBase> storedFunc_;
-
-        // True once the coroutine has completed or expectEarlyExit() was
-        // called. Asserted in the destructor (debug) to catch leaked
-        // runners. Available in all builds to guard expectEarlyExit()
-        // against double-decrementing nSuspend_.
-        // Atomic to allow lock-free reads from runnable(), join(), and
-        // the destructor without requiring the same mutex that guards
-        // the write in resume().
-        std::atomic<bool> finished_{false};
+        boost::coroutines2::coroutine<void>::pull_type coro_;
+        boost::coroutines2::coroutine<void>::push_type* yield_;
+#ifndef NDEBUG
+        bool finished_ = false;
+#endif
 
     public:
-        /**
-         * Tag type for private construction. Prevents external code
-         * from constructing CoroTaskRunner directly. Use postCoroTask().
-         */
-        struct create_t
-        {
-            explicit create_t() = default;
-        };
-
-        /**
-         * Construct a CoroTaskRunner. Private by convention (create_t tag).
-         *
-         * @param jq   The JobQueue this coroutine will run on
-         * @param type Job type for scheduling priority
-         * @param name Human-readable name for logging
-         */
-        CoroTaskRunner(create_t, JobQueue&, JobType, std::string const&);
-
-        CoroTaskRunner(CoroTaskRunner const&) = delete;
-        CoroTaskRunner&
-        operator=(CoroTaskRunner const&) = delete;
-
-        /**
-         * Destructor. Asserts (debug) that the coroutine has finished
-         * or expectEarlyExit() was called.
-         */
-        ~CoroTaskRunner();
-
-        /**
-         * Initialize with a coroutine-returning callable.
-         * Must be called exactly once, after the object is managed by
-         * shared_ptr (because init uses shared_from_this internally).
-         * This is handled automatically by postCoroTask().
-         *
-         * @param f Callable: CoroTask<void>(shared_ptr<CoroTaskRunner>)
-         */
+        // Private: Used in the implementation
         template <class F>
+        Coro(Coro_create_t, JobQueue&, JobType, std::string const&, F&&);
+
+        // Not copy-constructible or assignable
+        Coro(Coro const&) = delete;
+        Coro&
+        operator=(Coro const&) = delete;
+
+        ~Coro();
+
+        /** Suspend coroutine execution.
+            Effects:
+              The coroutine's stack is saved.
+              The associated Job thread is released.
+            Note:
+              The associated Job function returns.
+              Undefined behavior if called consecutively without a corresponding
+           post.
+        */
         void
-        init(F&& f);
+        yield() const;
 
-        /**
-         * Increment the JobQueue's suspended-coroutine count (nSuspend_).
-         * Called when the coroutine is about to suspend. Every call
-         * must be balanced by a corresponding decrement (via resume()
-         * or onUndoSuspend()), or JobQueue::stop() will hang.
-         */
-        void
-        onSuspend();
+        /** Schedule coroutine execution.
+            Effects:
+              Returns immediately.
+              A new job is scheduled to resume the execution of the coroutine.
+              When the job runs, the coroutine's stack is restored and execution
+                continues at the beginning of coroutine function or the
+           statement after the previous call to yield. Undefined behavior if
+           called after the coroutine has completed with a return (as opposed to
+           a yield()). Undefined behavior if post() or resume() called
+           consecutively without a corresponding yield.
 
-        /**
-         * Decrement nSuspend_ without resuming.
-         * Used to undo onSuspend() when a scheduled post() fails
-         * (e.g. JobQueue is stopping).
-         */
-        void
-        onUndoSuspend();
-
-        /**
-         * Suspend the coroutine.
-         * The awaiter's await_suspend() increments nSuspend_ before the
-         * coroutine actually suspends. The caller must later call post()
-         * or resume() to continue execution.
-         *
-         * @return An awaiter for use with `co_await runner->suspend()`
-         */
-        auto
-        suspend();
-
-        /**
-         * Suspend the coroutine and immediately repost it on the
-         * JobQueue. Combines suspend() + post() atomically inside
-         * await_suspend, so there is no window where an external
-         * event could race between the two.
-         *
-         * Equivalent to JobQueueAwaiter but defined as an inline
-         * awaiter returned from a member function. This avoids a
-         * GCC-12 coroutine codegen bug where an external awaiter
-         * struct (JobQueueAwaiter) used at multiple co_await points
-         * corrupts the coroutine state machine's resume index,
-         * causing the coroutine to hang on the third resumption.
-         *
-         * @return An awaiter for use with `co_await runner->yieldAndPost()`
-         */
-        auto
-        yieldAndPost();
-
-        /**
-         * Schedule coroutine resumption as a job on the JobQueue.
-         * Captures shared_from_this() to prevent this runner from being
-         * destroyed while the job is queued.
-         *
-         * @return true if the job was accepted; false if the JobQueue
-         *         is stopping (caller must handle cleanup)
-         */
+            @return true if the Coro's job is added to the JobQueue.
+        */
         bool
         post();
 
-        /**
-         * Resume the coroutine on the current thread.
-         * Decrements nSuspend_, swaps in LocalValues, resumes the
-         * coroutine handle, swaps out LocalValues, and notifies join()
-         * waiters. Lock ordering (sequential, non-overlapping):
-         * jq_.m_mutex -> mutex_ -> mutex_run_.
-         *
-         * @pre post() must have been called before resume(). Direct
-         *      calls without a prior post() will corrupt runCount_
-         *      and break join().
-         */
+        /** Resume coroutine execution.
+            Effects:
+               The coroutine continues execution from where it last left off
+                 using this same thread.
+               If the coroutine has already completed, returns immediately
+                 (handles the documented post-before-yield race condition).
+            Undefined behavior if resume() or post() called consecutively
+              without a corresponding yield.
+        */
         void
         resume();
 
-        /**
-         * @return true if the coroutine has not yet run to completion
-         */
+        /** Returns true if the Coro is still runnable (has not returned). */
         bool
         runnable() const;
 
-        /**
-         * Handle early termination when the coroutine never ran.
-         * Decrements nSuspend_ and destroys the coroutine frame to
-         * break the shared_ptr cycle (frame -> lambda -> runner -> frame).
-         * Called by postCoroTask() when post() fails.
-         */
+        /** Once called, the Coro allows early exit without an assert. */
         void
         expectEarlyExit();
 
-        /**
-         * Block until all pending/active resume operations complete.
-         * Uses cv_ + mutex_run_ to wait until runCount_ reaches 0.
-         * Warning: deadlocks if the coroutine is suspended and never posted.
-         */
+        /** Waits until coroutine returns from the user function. */
         void
         join();
     };
@@ -481,18 +153,18 @@ public:
         return false;
     }
 
-    /** Creates a C++20 coroutine and adds a job to the queue to run it.
+    /** Creates a coroutine and adds a job to the queue which will run it.
 
         @param t The type of job.
         @param name Name of the job.
-        @param f Callable with signature
-            CoroTask<void>(std::shared_ptr<CoroTaskRunner>).
+        @param f Has a signature of void(std::shared_ptr<Coro>). Called when the
+       job executes.
 
-        @return shared_ptr to posted CoroTaskRunner. nullptr if not successful.
+        @return shared_ptr to posted Coro.  nullptr if post was not successful.
     */
     template <class F>
-    std::shared_ptr<CoroTaskRunner>
-    postCoroTask(JobType t, std::string const& name, F&& f);
+    std::shared_ptr<Coro>
+    postCoro(JobType t, std::string const& name, F&& f);
 
     /** Jobs waiting at this priority.
      */
@@ -546,11 +218,13 @@ public:
     isStopped() const;
 
 private:
+    friend class Coro;
+
     using JobDataMap = std::map<JobType, JobTypeData>;
 
     beast::Journal m_journal;
     mutable std::mutex m_mutex;
-    std::uint64_t m_lastJob;
+    std::uint64_t m_lastJob{0};
     std::set<Job> m_jobSet;
     JobCounter jobCounter_;
     std::atomic_bool stopping_{false};
@@ -559,7 +233,7 @@ private:
     JobTypeData m_invalidJobData;
 
     // The number of jobs currently in processTask()
-    int m_processCount;
+    int m_processCount{0};
 
     // The number of suspended coroutines
     int nSuspend_ = 0;
@@ -646,75 +320,88 @@ private:
     getJobLimit(JobType type);
 };
 
+/*
+    An RPC command is received and is handled via ServerHandler(HTTP) or
+    Handler(websocket), depending on the connection type. The handler then calls
+    the JobQueue::postCoro() method to create a coroutine and run it at a later
+    point. This frees up the handler thread and allows it to continue handling
+    other requests while the RPC command completes its work asynchronously.
+
+    postCoro() creates a Coro object. When the Coro ctor is called, and its
+    coro_ member is initialized (a boost::coroutines::pull_type), execution
+    automatically passes to the coroutine, which we don't want at this point,
+    since we are still in the handler thread context. It's important to note
+   here that construction of a boost pull_type automatically passes execution to
+   the coroutine. A pull_type object automatically generates a push_type that is
+    passed as a parameter (do_yield) in the signature of the function the
+    pull_type was created with. This function is immediately called during coro_
+    construction and within it, Coro::yield_ is assigned the push_type
+    parameter (do_yield) address and called (yield()) so we can return execution
+    back to the caller's stack.
+
+    postCoro() then calls Coro::post(), which schedules a job on the job
+    queue to continue execution of the coroutine in a JobQueue worker thread at
+    some later time. When the job runs, we lock on the Coro::mutex_ and call
+    coro_ which continues where we had left off. Since we the last thing we did
+    in coro_ was call yield(), the next thing we continue with is calling the
+    function param f, that was passed into Coro ctor. It is within this
+    function body that the caller specifies what he would like to do while
+    running in the coroutine and allow them to suspend and resume execution.
+    A task that relies on other events to complete, such as path finding, calls
+    Coro::yield() to suspend its execution while waiting on those events to
+    complete and continue when signaled via the Coro::post() method.
+
+    There is a potential race condition that exists here where post() can get
+    called before yield() after f is called. Technically the problem only occurs
+    if the job that post() scheduled is executed before yield() is called.
+    If the post() job were to be executed before yield(), undefined behavior
+    would occur. The lock ensures that coro_ is not called again until we exit
+    the coroutine. At which point a scheduled resume() job waiting on the lock
+    would gain entry. resume() checks if the coroutine has already completed
+    (coro_ converts to false) and, if so, skips invoking operator() since
+    calling operator() on a completed boost::coroutine2 pull_type is undefined
+    behavior.
+
+    The race condition occurs as follows:
+
+        1- The coroutine is running.
+        2- The coroutine is about to suspend, but before it can do so, it must
+            arrange for some event to wake it up.
+        3- The coroutine arranges for some event to wake it up.
+        4- Before the coroutine can suspend, that event occurs and the
+   resumption of the coroutine is scheduled on the job queue. 5- Again, before
+   the coroutine can suspend, the resumption of the coroutine is dispatched. 6-
+   Again, before the coroutine can suspend, the resumption code runs the
+            coroutine.
+        The coroutine is now running in two threads.
+
+        The lock prevents this from happening as step 6 will block until the
+            lock is released which only happens after the coroutine completes.
+*/
+
 }  // namespace xrpl
 
-#include <xrpl/core/CoroTaskRunner.ipp>
+#include <xrpl/core/Coro.ipp>
 
 namespace xrpl {
 
-// postCoroTask — entry point for launching a C++20 coroutine on the JobQueue.
-//
-// Control Flow
-// ============
-//
-//   postCoroTask(t, name, f)
-//     |
-//     +-- 1. Check stopping_ — reject if JQ shutting down
-//     |
-//     +-- 2. ++nSuspend_   (the coroutine uses lazy-start, so it is
-//     |        "suspended" from the JQ's perspective before its first resume.
-//     |        This keeps the JQ shutdown logic correct — it waits for
-//     |        nSuspend_ to reach 0).
-//     |
-//     +-- 3. Create CoroTaskRunner (shared_ptr, ref-counted)
-//     |
-//     +-- 4. runner->init(f)
-//     |        +-- Heap-allocate the lambda (FuncStore) to prevent
-//     |        |   dangling captures in the coroutine frame
-//     |        +-- task_ = f(shared_from_this())
-//     |              [coroutine created but NOT started — lazy initial_suspend]
-//     |
-//     +-- 5. runner->post()
-//     |        +-- addJob(type_, [resume]{})   → resume on worker thread
-//     |        +-- failure (JQ stopping):
-//     |              +-- runner->expectEarlyExit()
-//     |              |     --nSuspend_, destroy coroutine frame
-//     |              +-- return nullptr
-//
-// Why async post() instead of synchronous resume()?
-// ==================================================
-// The initial dispatch MUST use async post() so the coroutine body runs on
-// a JobQueue worker thread, not the caller's thread.  resume() swaps the
-// caller's thread-local LocalValues with the coroutine's private copy.
-// If the coroutine mutates LocalValues (e.g. thread_specific_storage test),
-// those mutations bleed back into the caller's thread-local state after the
-// swap-out, corrupting subsequent tests that share the same thread pool.
-// Async post() avoids this by running the coroutine on a worker thread whose
-// LocalValues are managed by the thread pool, not by the caller.
-//
 template <class F>
-std::shared_ptr<JobQueue::CoroTaskRunner>
-JobQueue::postCoroTask(JobType t, std::string const& name, F&& f)
+std::shared_ptr<JobQueue::Coro>
+JobQueue::postCoro(JobType t, std::string const& name, F&& f)
 {
-    // Reject if the JQ is shutting down and atomically increment
-    // nSuspend_ under the same lock. Without the lock, a TOCTOU race
-    // exists: stopping_ could become true between the check and the
-    // increment, leaving an orphan nSuspend_ that causes stop() to hang.
+    /*  First param is a detail type to make construction private.
+        Last param is the function the coroutine runs. Signature of
+        void(std::shared_ptr<Coro>).
+    */
+    auto coro = std::make_shared<Coro>(Coro_create_t{}, *this, t, name, std::forward<F>(f));
+    if (!coro->post())
     {
-        std::lock_guard lock(m_mutex);
-        if (stopping_)
-            return nullptr;
-        ++nSuspend_;
+        // The Coro was not successfully posted.  Disable it so it's destructor
+        // can run with no negative side effects.  Then destroy it.
+        coro->expectEarlyExit();
+        coro.reset();
     }
-
-    auto runner = std::make_shared<CoroTaskRunner>(CoroTaskRunner::create_t{}, *this, t, name);
-    runner->init(std::forward<F>(f));
-    if (!runner->post())
-    {
-        runner->expectEarlyExit();
-        runner.reset();
-    }
-    return runner;
+    return coro;
 }
 
 }  // namespace xrpl

include/xrpl/core/JobQueueAwaiter.h

@@ -1,206 +0,0 @@
-#pragma once
-
-#include <xrpl/core/JobQueue.h>
-
-#include <coroutine>
-#include <memory>
-
-namespace xrpl {
-
-/**
- * Awaiter that suspends and immediately reschedules on the JobQueue.
- * Equivalent to calling yield() followed by post() in the old Coro API.
- *
- * Usage:
- *     co_await JobQueueAwaiter{runner};
- *
- * What it waits for: The coroutine is re-queued as a job and resumes
- * when a worker thread picks it up.
- *
- * Which thread resumes: A JobQueue worker thread.
- *
- * What await_resume() returns: void.
- *
- * Dependency Diagram
- * ==================
- *
- *   JobQueueAwaiter
- *   +----------------------------------------------+
- *   | + runner : shared_ptr<CoroTaskRunner>         |
- *   +----------------------------------------------+
- *   | + await_ready()   -> false (always suspend)   |
- *   | + await_suspend() -> bool (suspend or cancel) |
- *   | + await_resume()  -> void                     |
- *   +----------------------------------------------+
- *          |                         |
- *          | uses                    | uses
- *          v                         v
- *   CoroTaskRunner              JobQueue
- *   .onSuspend()                (via runner->post() -> addJob)
- *   .onUndoSuspend()
- *   .post()
- *
- * Control Flow (await_suspend)
- * ============================
- *
- *   co_await JobQueueAwaiter{runner}
- *     |
- *     +-- await_ready() -> false
- *     +-- await_suspend(handle)
- *           |
- *           +-- runner->onSuspend()     // ++nSuspend_
- *           +-- runner->post()          // addJob to JobQueue
- *           |     |
- *           |     +-- success? return noop_coroutine()
- *           |     |     // coroutine stays suspended;
- *           |     |     // worker thread will call resume()
- *           |     +-- failure? (JQ stopping)
- *           |           +-- runner->onUndoSuspend()  // --nSuspend_
- *           |           +-- return handle  // symmetric transfer back
- *           |                              // coroutine continues immediately
- *           |                              // so it can clean up and co_return
- *
- * DEPRECATED — prefer `co_await runner->yieldAndPost()`
- * =====================================================
- *
- * GCC-12 has a coroutine codegen bug where using this external awaiter
- * struct at multiple co_await points in the same coroutine corrupts the
- * state machine's resume index. After the second co_await, the third
- * resumption enters handle().resume() but never reaches await_resume()
- * or any subsequent user code — the coroutine hangs indefinitely.
- *
- * The fix is `co_await runner->yieldAndPost()`, which defines the
- * awaiter as an inline struct inside a CoroTaskRunner member function.
- * GCC-12 handles inline awaiters correctly at multiple co_await points.
- *
- * This struct is retained for single-use scenarios and documentation
- * purposes. For any code that may use co_await in a loop or at
- * multiple points, always use `runner->yieldAndPost()`.
- *
- * Usage Examples
- * ==============
- *
- * 1. Yield and auto-repost (preferred — works on all compilers):
- *
- *     CoroTask<void> handler(auto runner) {
- *         doPartA();
- *         co_await runner->yieldAndPost();   // yield + repost
- *         doPartB();                         // runs on a worker thread
- *         co_return;
- *     }
- *
- * 2. Multiple yield points in a loop:
- *
- *     CoroTask<void> batchProcessor(auto runner) {
- *         for (auto& item : items) {
- *             process(item);
- *             co_await runner->yieldAndPost();  // let other jobs run
- *         }
- *         co_return;
- *     }
- *
- * 3. Graceful shutdown — checking after resume:
- *
- *     CoroTask<void> longTask(auto runner, JobQueue& jq) {
- *         while (hasWork()) {
- *             co_await runner->yieldAndPost();
- *             // If JQ is stopping, await_suspend resumes the coroutine
- *             // immediately without re-queuing. Always check
- *             // isStopping() to decide whether to proceed:
- *             if (jq.isStopping())
- *                 co_return;
- *             doNextChunk();
- *         }
- *         co_return;
- *     }
- *
- * Caveats / Pitfalls
- * ==================
- *
- * BUG-RISK: Using a stale or null runner.
- *   The runner shared_ptr must be valid and point to the CoroTaskRunner
- *   that owns the coroutine currently executing. Passing a runner from
- *   a different coroutine, or a default-constructed shared_ptr, is UB.
- *
- * BUG-RISK: Assuming resume happens on the same thread.
- *   After co_await, the coroutine resumes on whatever worker thread
- *   picks up the job. Do not rely on thread-local state unless it is
- *   managed through LocalValue (which CoroTaskRunner automatically
- *   swaps in/out).
- *
- * BUG-RISK: Ignoring the shutdown path.
- *   When the JobQueue is stopping, post() fails and await_suspend()
- *   resumes the coroutine immediately (symmetric transfer back to h).
- *   The coroutine body continues on the same thread. If your code
- *   after co_await assumes it was re-queued and is running on a worker
- *   thread, that assumption breaks during shutdown. Always handle the
- *   "JQ is stopping" case, either by checking jq.isStopping() or by
- *   letting the coroutine fall through to co_return naturally.
- *
- * DIFFERENCE from runner->suspend() + runner->post():
- *   Both JobQueueAwaiter and yieldAndPost() combine suspend + post
- *   in one atomic operation. With the manual suspend()/post() pattern,
- *   there is a window between the two calls where an external event
- *   could race. The atomic awaiters remove that window — onSuspend()
- *   and post() happen within the same await_suspend() call while the
- *   coroutine is guaranteed to be suspended. Use yieldAndPost() unless
- *   you need an external party to decide *when* to call post().
- */
-struct JobQueueAwaiter
-{
-    // The CoroTaskRunner that owns the currently executing coroutine.
-    std::shared_ptr<JobQueue::CoroTaskRunner> runner;
-
-    /**
-     * Always returns false so the coroutine suspends.
-     */
-    bool
-    await_ready() const noexcept
-    {
-        return false;
-    }
-
-    /**
-     * Increment nSuspend (equivalent to yield()) and schedule resume
-     * on the JobQueue (equivalent to post()). If the JobQueue is
-     * stopping, undoes the suspend count and transfers back to the
-     * coroutine so it can clean up and co_return.
-     *
-     * Returns a coroutine_handle<> (symmetric transfer) instead of
-     * bool to work around a GCC-12 codegen bug where bool-returning
-     * await_suspend leaves the coroutine in an invalid state —
-     * neither properly suspended nor resumed — causing a hang.
-     *
-     * WARNING: GCC-12 has an additional codegen bug where using this
-     * external awaiter struct at multiple co_await points in the same
-     * coroutine corrupts the state machine's resume index, causing the
-     * coroutine to hang on the third resumption. Prefer
-     * `co_await runner->yieldAndPost()` which uses an inline awaiter
-     * that GCC-12 handles correctly.
-     *
-     * @return noop_coroutine() to stay suspended (job posted);
-     *         the caller's handle to resume immediately (JQ stopping)
-     */
-    std::coroutine_handle<>
-    await_suspend(std::coroutine_handle<> h)
-    {
-        XRPL_ASSERT(runner, "xrpl::JobQueueAwaiter::await_suspend : runner is valid");
-        runner->onSuspend();
-        if (!runner->post())
-        {
-            // JobQueue is stopping. Undo the suspend count and
-            // transfer back to the coroutine so it can clean up
-            // and co_return.
-            runner->onUndoSuspend();
-            return h;
-        }
-        return std::noop_coroutine();
-    }
-
-    void
-    await_resume() const noexcept
-    {
-    }
-};
-
-}  // namespace xrpl

include/xrpl/core/JobTypeData.h

@@ -19,13 +19,13 @@ public:
     JobTypeInfo const& info;
 
     /* The number of jobs waiting */
-    int waiting;
+    int waiting{0};
 
     /* The number presently running */
-    int running;
+    int running{0};
 
     /* And the number we deferred executing because of job limits */
-    int deferred;
+    int deferred{0};
 
     /* Notification callbacks */
     beast::insight::Event dequeue;
@@ -35,12 +35,8 @@ public:
         JobTypeInfo const& info_,
         beast::insight::Collector::ptr const& collector,
         Logs& logs) noexcept
-        : m_load(logs.journal("LoadMonitor"))
-        , m_collector(collector)
-        , info(info_)
-        , waiting(0)
-        , running(0)
-        , deferred(0)
+        : m_load(logs.journal("LoadMonitor")), m_collector(collector), info(info_)
+
     {
         m_load.setTargetLatency(info.getAverageLatency(), info.getPeakLatency());
 

include/xrpl/core/JobTypes.h

@@ -24,7 +24,7 @@ private:
               std::chrono::milliseconds{0})
     {
         using namespace std::chrono_literals;
-        int maxLimit = std::numeric_limits<int>::max();
+        int const maxLimit = std::numeric_limits<int>::max();
 
         auto add = [this](
                        JobType jt,

include/xrpl/core/LoadMonitor.h

@@ -36,10 +36,10 @@ public:
     {
         Stats();
 
-        std::uint64_t count;
+        std::uint64_t count{0};
         std::chrono::milliseconds latencyAvg;
         std::chrono::milliseconds latencyPeak;
-        bool isOverloaded;
+        bool isOverloaded{false};
     };
 
     Stats
@@ -54,8 +54,8 @@ private:
 
     std::mutex mutex_;
 
-    std::uint64_t mCounts;
-    int mLatencyEvents;
+    std::uint64_t mCounts{0};
+    int mLatencyEvents{0};
     std::chrono::milliseconds mLatencyMSAvg;
     std::chrono::milliseconds mLatencyMSPeak;
     std::chrono::milliseconds mTargetLatencyAvg;

include/xrpl/core/PeerReservationTable.h

@@ -67,7 +67,7 @@ public:
     bool
     contains(PublicKey const& nodeId)
     {
-        std::lock_guard lock(this->mutex_);
+        std::lock_guard const lock(this->mutex_);
         return table_.find({nodeId}) != table_.end();
     }
 
@@ -92,7 +92,7 @@ public:
 private:
     beast::Journal mutable journal_;
     std::mutex mutable mutex_;
-    DatabaseCon* connection_;
+    DatabaseCon* connection_{};
     std::unordered_set<PeerReservation, beast::uhash<>, KeyEqual> table_;
 };
 

include/xrpl/core/PerfLog.h

@@ -14,7 +14,7 @@
 
 namespace beast {
 class Journal;
-}
+}  // namespace beast
 
 namespace xrpl {
 class Application;

include/xrpl/core/ServiceRegistry.h

@@ -3,7 +3,6 @@
 #include <xrpl/basics/Blob.h>
 #include <xrpl/basics/SHAMapHash.h>
 #include <xrpl/basics/TaggedCache.h>
-#include <xrpl/ledger/CachedSLEs.h>
 
 #include <boost/asio.hpp>
 
@@ -12,17 +11,31 @@ namespace xrpl {
 // Forward declarations
 namespace NodeStore {
 class Database;
-}
+}  // namespace NodeStore
 namespace Resource {
 class Manager;
-}
+}  // namespace Resource
 namespace perf {
 class PerfLog;
-}
+}  // namespace perf
 
 // This is temporary until we migrate all code to use ServiceRegistry.
 class Application;
 
+template <
+    class Key,
+    class T,
+    bool IsKeyCache,
+    class SharedWeakUnionPointer,
+    class SharedPointerType,
+    class Hash,
+    class KeyEqual,
+    class Mutex>
+class TaggedCache;
+class STLedgerEntry;
+using SLE = STLedgerEntry;
+using CachedSLEs = TaggedCache<uint256, SLE const>;
+
 // Forward declarations
 class AcceptedLedger;
 class AmendmentTable;
@@ -45,7 +58,7 @@ class NetworkIDService;
 class OpenLedger;
 class OrderBookDB;
 class Overlay;
-class PathRequests;
+class PathRequestManager;
 class PeerReservationTable;
 class PendingSaves;
 class RelationalDatabase;
@@ -89,7 +102,7 @@ public:
     getNodeFamily() = 0;
 
     virtual TimeKeeper&
-    timeKeeper() = 0;
+    getTimeKeeper() = 0;
 
     virtual JobQueue&
     getJobQueue() = 0;
@@ -98,7 +111,7 @@ public:
     getTempNodeCache() = 0;
 
     virtual CachedSLEs&
-    cachedSLEs() = 0;
+    getCachedSLEs() = 0;
 
     virtual NetworkIDService&
     getNetworkIDService() = 0;
@@ -120,26 +133,26 @@ public:
     getValidations() = 0;
 
     virtual ValidatorList&
-    validators() = 0;
+    getValidators() = 0;
 
     virtual ValidatorSite&
-    validatorSites() = 0;
+    getValidatorSites() = 0;
 
     virtual ManifestCache&
-    validatorManifests() = 0;
+    getValidatorManifests() = 0;
 
     virtual ManifestCache&
-    publisherManifests() = 0;
+    getPublisherManifests() = 0;
 
     // Network services
     virtual Overlay&
-    overlay() = 0;
+    getOverlay() = 0;
 
     virtual Cluster&
-    cluster() = 0;
+    getCluster() = 0;
 
     virtual PeerReservationTable&
-    peerReservations() = 0;
+    getPeerReservations() = 0;
 
     virtual Resource::Manager&
     getResourceManager() = 0;
@@ -174,13 +187,13 @@ public:
     getLedgerReplayer() = 0;
 
     virtual PendingSaves&
-    pendingSaves() = 0;
+    getPendingSaves() = 0;
 
     virtual OpenLedger&
-    openLedger() = 0;
+    getOpenLedger() = 0;
 
     virtual OpenLedger const&
-    openLedger() const = 0;
+    getOpenLedger() const = 0;
 
     // Transaction and operation services
     virtual NetworkOPs&
@@ -195,8 +208,8 @@ public:
     virtual TxQ&
     getTxQ() = 0;
 
-    virtual PathRequests&
-    getPathRequests() = 0;
+    virtual PathRequestManager&
+    getPathRequestManager() = 0;
 
     // Server services
     virtual ServerHandler&
@@ -210,16 +223,16 @@ public:
     isStopping() const = 0;
 
     virtual beast::Journal
-    journal(std::string const& name) = 0;
+    getJournal(std::string const& name) = 0;
 
     virtual boost::asio::io_context&
     getIOContext() = 0;
 
     virtual Logs&
-    logs() = 0;
+    getLogs() = 0;
 
     virtual std::optional<uint256> const&
-    trapTxID() const = 0;
+    getTrapTxID() const = 0;
 
     /** Retrieve the "wallet database" */
     virtual DatabaseCon&
@@ -228,7 +241,7 @@ public:
     // Temporary: Get the underlying Application for functions that haven't
     // been migrated yet. This should be removed once all code is migrated.
     virtual Application&
-    app() = 0;
+    getApp() = 0;
 };
 
 }  // namespace xrpl

include/xrpl/core/StartUpType.h

@@ -5,7 +5,7 @@
 
 namespace xrpl {
 
-enum class StartUpType { FRESH, NORMAL, LOAD, LOAD_FILE, REPLAY, NETWORK };
+enum class StartUpType { Fresh, Normal, Load, LoadFile, Replay, Network };
 
 inline std::ostream&
 operator<<(std::ostream& os, StartUpType const& type)

include/xrpl/core/detail/Workers.h

@@ -13,7 +13,7 @@ namespace xrpl {
 
 namespace perf {
 class PerfLog;
-}
+}  // namespace perf
 
 /**
  * `Workers` is effectively a thread pool. The constructor takes a "callback"
@@ -183,8 +183,8 @@ private:
         std::thread thread_;
         std::mutex mutex_;
         std::condition_variable wakeup_;
-        int wakeCount_;  // how many times to un-pause
-        bool shouldExit_;
+        int wakeCount_{0};  // how many times to un-pause
+        bool shouldExit_{false};
     };
 
 private:
@@ -197,9 +197,9 @@ private:
     std::string m_threadNames;     // The name to give each thread
     std::condition_variable m_cv;  // signaled when all threads paused
     std::mutex m_mut;
-    bool m_allPaused;
+    bool m_allPaused{true};
     semaphore m_semaphore;                             // each pending task is 1 resource
-    int m_numberOfThreads;                             // how many we want active now
+    int m_numberOfThreads{0};                          // how many we want active now
     std::atomic<int> m_activeCount;                    // to know when all are paused
     std::atomic<int> m_pauseCount;                     // how many threads need to pause now
     std::atomic<int> m_runningTaskCount;               // how many calls to processTask() active

include/xrpl/core/detail/semaphore.h

@@ -55,7 +55,7 @@ public:
     void
     notify()
     {
-        std::lock_guard lock{m_mutex};
+        std::lock_guard const lock{m_mutex};
         ++m_count;
         m_cond.notify_one();
     }

include/xrpl/json/json_reader.h

@@ -103,9 +103,9 @@ private:
     public:
         explicit ErrorInfo() = default;
 
-        Token token_;
+        Token token_{};
         std::string message_;
-        Location extra_;
+        Location extra_{};
     };
 
     using Errors = std::deque<ErrorInfo>;
@@ -173,11 +173,11 @@ private:
     Nodes nodes_;
     Errors errors_;
     std::string document_;
-    Location begin_;
-    Location end_;
-    Location current_;
-    Location lastValueEnd_;
-    Value* lastValue_;
+    Location begin_{};
+    Location end_{};
+    Location current_{};
+    Location lastValueEnd_{};
+    Value* lastValue_{};
 };
 
 template <class BufferSequence>

include/xrpl/json/json_value.h

@@ -641,7 +641,7 @@ public:
     SelfType
     operator++(int)
     {
-        SelfType temp(*this);
+        SelfType const temp(*this);
         ++*this;
         return temp;
     }
@@ -649,7 +649,7 @@ public:
     SelfType
     operator--(int)
     {
-        SelfType temp(*this);
+        SelfType const temp(*this);
         --*this;
         return temp;
     }

include/xrpl/json/json_writer.h

@@ -106,8 +106,8 @@ private:
     ChildValues childValues_;
     std::string document_;
     std::string indentString_;
-    int rightMargin_;
-    int indentSize_;
+    int rightMargin_{74};
+    int indentSize_{3};
     bool addChildValues_{};
 };
 
@@ -171,9 +171,9 @@ private:
     using ChildValues = std::vector<std::string>;
 
     ChildValues childValues_;
-    std::ostream* document_;
+    std::ostream* document_{nullptr};
     std::string indentString_;
-    int rightMargin_;
+    int rightMargin_{74};
     std::string indentation_;
     bool addChildValues_{};
 };

include/xrpl/ledger/AmendmentTable.h

@@ -143,7 +143,7 @@ public:
         // Inject appropriate pseudo-transactions
         for (auto const& it : actions)
         {
-            STTx amendTx(ttAMENDMENT, [&it, seq = lastClosedLedger->seq() + 1](auto& obj) {
+            STTx const amendTx(ttAMENDMENT, [&it, seq = lastClosedLedger->seq() + 1](auto& obj) {
                 obj.setAccountID(sfAccount, AccountID());
                 obj.setFieldH256(sfAmendment, it.first);
                 obj.setFieldU32(sfLedgerSequence, seq);

include/xrpl/ledger/CachedSLEs.h

@@ -6,4 +6,4 @@
 
 namespace xrpl {
 using CachedSLEs = TaggedCache<uint256, SLE const>;
-}
+}  // namespace xrpl

include/xrpl/ledger/Ledger.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <xrpld/core/Config.h>
-#include <xrpld/core/TimeKeeper.h>
-
 #include <xrpl/basics/CountedObject.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/ledger/CachedView.h>
 #include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Fees.h>
 #include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/TxMeta.h>
@@ -15,7 +14,7 @@
 
 namespace xrpl {
 
-class Application;
+class ServiceRegistry;
 class Job;
 class TransactionMaster;
 
@@ -83,21 +82,26 @@ public:
     */
     Ledger(
         create_genesis_t,
-        Config const& config,
+        Rules const& rules,
+        Fees const& fees,
         std::vector<uint256> const& amendments,
         Family& family);
 
-    Ledger(LedgerHeader const& info, Config const& config, Family& family);
+    Ledger(LedgerHeader const& info, Rules const& rules, Family& family);
 
     /** Used for ledgers loaded from JSON files
 
         @param acquire If true, acquires the ledger if not found locally
+
+        @note The fees parameter provides default values, but setup() may
+              override them from the ledger state if fee-related SLEs exist.
     */
     Ledger(
         LedgerHeader const& info,
         bool& loaded,
         bool acquire,
-        Config const& config,
+        Rules const& rules,
+        Fees const& fees,
         Family& family,
         beast::Journal j);
 
@@ -113,7 +117,8 @@ public:
     Ledger(
         std::uint32_t ledgerSeq,
         NetClock::time_point closeTime,
-        Config const& config,
+        Rules const& rules,
+        Fees const& fees,
         Family& family);
 
     ~Ledger() = default;
@@ -322,7 +327,7 @@ public:
     walkLedger(beast::Journal j, bool parallel = false) const;
 
     bool
-    assertSensible(beast::Journal ledgerJ) const;
+    isSensible() const;
 
     void
     invariants() const;
@@ -379,8 +384,26 @@ private:
     bool
     setup();
 
-    void
-    defaultFees(Config const& config);
+    /** @brief Deserialize a SHAMapItem containing a single STTx.
+     *
+     * @param item The SHAMapItem to deserialize.
+     * @return A shared pointer to the deserialized transaction.
+     * @throw May throw on deserialization error.
+     */
+    static std::shared_ptr<STTx const>
+    deserializeTx(SHAMapItem const& item);
+
+    /** @brief Deserialize a SHAMapItem containing STTx + STObject metadata.
+     *
+     * The SHAMapItem must contain two variable length serialization objects.
+     *
+     * @param item The SHAMapItem to deserialize.
+     * @return A pair containing shared pointers to the deserialized transaction
+     *         and metadata.
+     * @throw May throw on deserialization error.
+     */
+    static std::pair<std::shared_ptr<STTx const>, std::shared_ptr<STObject const>>
+    deserializeTxPlusMeta(SHAMapItem const& item);
 
     bool mImmutable;
 
@@ -402,54 +425,4 @@ private:
 /** A ledger wrapped in a CachedView. */
 using CachedLedger = CachedView<Ledger>;
 
-//------------------------------------------------------------------------------
-//
-// API
-//
-//------------------------------------------------------------------------------
-
-extern bool
-pendSaveValidated(
-    Application& app,
-    std::shared_ptr<Ledger const> const& ledger,
-    bool isSynchronous,
-    bool isCurrent);
-
-std::shared_ptr<Ledger>
-loadLedgerHelper(LedgerHeader const& sinfo, Application& app, bool acquire);
-
-std::shared_ptr<Ledger>
-loadByIndex(std::uint32_t ledgerIndex, Application& app, bool acquire = true);
-
-std::shared_ptr<Ledger>
-loadByHash(uint256 const& ledgerHash, Application& app, bool acquire = true);
-
-// Fetch the ledger with the highest sequence contained in the database
-extern std::tuple<std::shared_ptr<Ledger>, std::uint32_t, uint256>
-getLatestLedger(Application& app);
-
-/** Deserialize a SHAMapItem containing a single STTx
-
-    Throw:
-
-        May throw on deserializaton error
-*/
-std::shared_ptr<STTx const>
-deserializeTx(SHAMapItem const& item);
-
-/** Deserialize a SHAMapItem containing STTx + STObject metadata
-
-    The SHAMap must contain two variable length
-    serialization objects.
-
-    Throw:
-
-        May throw on deserializaton error
-*/
-std::pair<std::shared_ptr<STTx const>, std::shared_ptr<STObject const>>
-deserializeTxPlusMeta(SHAMapItem const& item);
-
-uint256
-calculateLedgerHash(LedgerHeader const& info);
-
 }  // namespace xrpl

include/xrpl/ledger/OrderBookDB.h

@@ -76,16 +76,33 @@ public:
         @return true if a book from this issue to XRP exists
     */
     virtual bool
-    isBookToXRP(Issue const& issue, std::optional<Domain> domain = std::nullopt) = 0;
+    isBookToXRP(Issue const& issue, std::optional<Domain> const& domain = std::nullopt) = 0;
 
+    /**
+     * Process a transaction for order book tracking.
+     * @param ledger The ledger the transaction was applied to
+     * @param alTx The transaction to process
+     * @param jvObj The JSON object of the transaction
+     */
     virtual void
     processTxn(
         std::shared_ptr<ReadView const> const& ledger,
         AcceptedLedgerTx const& alTx,
         MultiApiJson const& jvObj) = 0;
 
+    /**
+     * Get the book listeners for a book.
+     * @param book The book to get the listeners for
+     * @return The book listeners for the book
+     */
     virtual BookListeners::pointer
     getBookListeners(Book const&) = 0;
+
+    /**
+     * Create a new book listeners for a book.
+     * @param book The book to create the listeners for
+     * @return The new book listeners for the book
+     */
     virtual BookListeners::pointer
     makeBookListeners(Book const&) = 0;
 };

include/xrpl/ledger/PendingSaves.h

@@ -31,7 +31,7 @@ public:
     bool
     startWork(LedgerIndex seq)
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         auto it = map_.find(seq);
 
@@ -54,7 +54,7 @@ public:
     void
     finishWork(LedgerIndex seq)
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         map_.erase(seq);
         await_.notify_all();
@@ -64,7 +64,7 @@ public:
     bool
     pending(LedgerIndex seq)
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return map_.find(seq) != map_.end();
     }
 
@@ -117,7 +117,7 @@ public:
     std::map<LedgerIndex, bool>
     getSnapshot() const
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         return map_;
     }

include/xrpl/nodestore/Scheduler.h

@@ -16,7 +16,7 @@ struct FetchReport
     {
     }
 
-    std::chrono::milliseconds elapsed;
+    std::chrono::milliseconds elapsed{};
     FetchType const fetchType;
     bool wasFound = false;
 };

include/xrpl/nodestore/detail/BatchWriter.h

@@ -71,8 +71,8 @@ private:
     Scheduler& m_scheduler;
     LockType mWriteMutex;
     CondvarType mWriteCondition;
-    int mWriteLoad;
-    bool mWritePending;
+    int mWriteLoad{0};
+    bool mWritePending{false};
     Batch mWriteSet;
 };
 

include/xrpl/nodestore/detail/EncodedBlob.h

@@ -35,7 +35,7 @@ namespace NodeStore {
 class EncodedBlob
 {
     /** The 32-byte key of the serialized object. */
-    std::array<std::uint8_t, 32> key_;
+    std::array<std::uint8_t, 32> key_{};
 
     /** A pre-allocated buffer for the serialized object.
 
@@ -43,7 +43,8 @@ class EncodedBlob
          1024 more bytes. The precise size is calculated automatically
          at compile time so as to avoid wasting space on padding bytes.
      */
-    std::array<std::uint8_t, boost::alignment::align_up(9 + 1024, alignof(std::uint32_t))> payload_;
+    std::array<std::uint8_t, boost::alignment::align_up(9 + 1024, alignof(std::uint32_t))>
+        payload_{};
 
     /** The size of the serialized data. */
     std::uint32_t size_;

include/xrpl/nodestore/detail/codec.h

@@ -56,7 +56,7 @@ lz4_compress(void const* in, std::size_t in_size, BufferFactory&& bf)
     using std::runtime_error;
     using namespace nudb::detail;
     std::pair<void const*, std::size_t> result;
-    std::array<std::uint8_t, varint_traits<std::size_t>::max> vi;
+    std::array<std::uint8_t, varint_traits<std::size_t>::max> vi{};
     auto const n = write_varint(vi.data(), in_size);
     auto const out_max = LZ4_compressBound(in_size);
     std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(n + out_max));
@@ -88,7 +88,7 @@ nodeobject_decompress(void const* in, std::size_t in_size, BufferFactory&& bf)
     using namespace nudb::detail;
 
     std::uint8_t const* p = reinterpret_cast<std::uint8_t const*>(in);
-    std::size_t type;
+    std::size_t type = 0;
     auto const vn = read_varint(p, in_size, type);
     if (vn == 0)
         Throw<std::runtime_error>("nodeobject decompress");
@@ -117,7 +117,7 @@ nodeobject_decompress(void const* in, std::size_t in_size, BufferFactory&& bf)
                     "nodeobject codec v1: short inner node size: " + std::string("in_size = ") +
                     std::to_string(in_size) + " hs = " + std::to_string(hs));
             istream is(p, in_size);
-            std::uint16_t mask;
+            std::uint16_t mask = 0;
             read<std::uint16_t>(is, mask);  // Mask
             in_size -= hs;
             result.second = 525;
@@ -196,10 +196,10 @@ nodeobject_compress(void const* in, std::size_t in_size, BufferFactory&& bf)
     if (in_size == 525)
     {
         istream is(in, in_size);
-        std::uint32_t index;
-        std::uint32_t unused;
-        std::uint8_t kind;
-        std::uint32_t prefix;
+        std::uint32_t index = 0;
+        std::uint32_t unused = 0;
+        std::uint8_t kind = 0;
+        std::uint32_t prefix = 0;
         read<std::uint32_t>(is, index);
         read<std::uint32_t>(is, unused);
         read<std::uint8_t>(is, kind);
@@ -208,7 +208,7 @@ nodeobject_compress(void const* in, std::size_t in_size, BufferFactory&& bf)
         {
             std::size_t n = 0;
             std::uint16_t mask = 0;
-            std::array<std::uint8_t, 512> vh;
+            std::array<std::uint8_t, 512> vh{};
             for (unsigned bit = 0x8000; bit; bit >>= 1)
             {
                 void const* const h = is(32);
@@ -247,7 +247,7 @@ nodeobject_compress(void const* in, std::size_t in_size, BufferFactory&& bf)
         }
     }
 
-    std::array<std::uint8_t, varint_traits<std::size_t>::max> vi;
+    std::array<std::uint8_t, varint_traits<std::size_t>::max> vi{};
 
     constexpr std::size_t codecType = 1;
     auto const vn = write_varint(vi.data(), codecType);
@@ -257,7 +257,7 @@ nodeobject_compress(void const* in, std::size_t in_size, BufferFactory&& bf)
         // case 0 was uncompressed data; we always compress now.
         case 1:  // lz4
         {
-            std::uint8_t* p;
+            std::uint8_t* p = nullptr;
             auto const lzr = NodeStore::lz4_compress(in, in_size, [&p, &vn, &bf](std::size_t n) {
                 p = reinterpret_cast<std::uint8_t*>(bf(vn + n));
                 return p + vn;
@@ -287,10 +287,10 @@ filter_inner(void* in, std::size_t in_size)
     if (in_size == 525)
     {
         istream is(in, in_size);
-        std::uint32_t index;
-        std::uint32_t unused;
-        std::uint8_t kind;
-        std::uint32_t prefix;
+        std::uint32_t index = 0;
+        std::uint32_t unused = 0;
+        std::uint8_t kind = 0;
+        std::uint32_t prefix = 0;
         read<std::uint32_t>(is, index);
         read<std::uint32_t>(is, unused);
         read<std::uint8_t>(is, kind);

include/xrpl/nodestore/detail/varint.h

@@ -82,6 +82,7 @@ template <class = void>
 std::size_t
 write_varint(void* p0, std::size_t v)
 {
+    // NOLINTNEXTLINE(misc-const-correctness)
     std::uint8_t* p = reinterpret_cast<std::uint8_t*>(p0);
     do
     {

include/xrpl/protocol/AmountConversions.h

@@ -102,7 +102,7 @@ template <typename T>
 T
 toAmount(Issue const& issue, Number const& n, Number::rounding_mode mode = Number::getround())
 {
-    saveNumberRoundMode rm(Number::getround());
+    saveNumberRoundMode const rm(Number::getround());
     if (isXRP(issue))
         Number::setround(mode);
 

include/xrpl/protocol/Fees.h

@@ -4,6 +4,10 @@
 
 namespace xrpl {
 
+// Deprecated constant for backwards compatibility with pre-XRPFees amendment.
+// This was the reference fee units used in the old fee calculation.
+inline constexpr std::uint32_t FEE_UNITS_DEPRECATED = 10;
+
 /** Reflects the fee settings for a particular ledger.
 
     The fees are always the same for any transactions applied
@@ -11,15 +15,25 @@ namespace xrpl {
 */
 struct Fees
 {
-    XRPAmount base{0};       // Reference tx cost (drops)
-    XRPAmount reserve{0};    // Reserve base (drops)
-    XRPAmount increment{0};  // Reserve increment (drops)
+    /** @brief Cost of a reference transaction in drops. */
+    XRPAmount base{0};
+
+    /** @brief Minimum XRP an account must hold to exist on the ledger. */
+    XRPAmount reserve{0};
+
+    /** @brief Additional XRP reserve required per owned ledger object. */
+    XRPAmount increment{0};
 
     explicit Fees() = default;
     Fees(Fees const&) = default;
     Fees&
     operator=(Fees const&) = default;
 
+    Fees(XRPAmount base_, XRPAmount reserve_, XRPAmount increment_)
+        : base(base_), reserve(reserve_), increment(increment_)
+    {
+    }
+
     /** Returns the account reserve given the owner count, in drops.
 
         The reserve is calculated as the reserve base plus

include/xrpl/protocol/IOUAmount.h

@@ -26,8 +26,8 @@ class IOUAmount : private boost::totally_ordered<IOUAmount>, private boost::addi
 private:
     using mantissa_type = std::int64_t;
     using exponent_type = int;
-    mantissa_type mantissa_;
-    exponent_type exponent_;
+    mantissa_type mantissa_{};
+    exponent_type exponent_{};
 
     /** Adjusts the mantissa and exponent to the proper range.
 

include/xrpl/protocol/Indexes.h

@@ -363,11 +363,12 @@ uint256
 getTicketIndex(AccountID const& account, SeqProxy ticketSeq);
 
 template <class... keyletParams>
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
 struct keyletDesc
 {
     std::function<Keylet(keyletParams...)> function;
     Json::StaticString expectedLEName;
-    bool includeInTests;
+    bool includeInTests{};
 };
 
 // This list should include all of the keylet functions that take a single

include/xrpl/protocol/Issue.h

@@ -96,7 +96,7 @@ operator<=>(Issue const& lhs, Issue const& rhs)
 inline Issue const&
 xrpIssue()
 {
-    static Issue issue{xrpCurrency(), xrpAccount()};
+    static Issue const issue{xrpCurrency(), xrpAccount()};
     return issue;
 }
 
@@ -104,7 +104,7 @@ xrpIssue()
 inline Issue const&
 noIssue()
 {
-    static Issue issue{noCurrency(), noAccount()};
+    static Issue const issue{noCurrency(), noAccount()};
     return issue;
 }
 

include/xrpl/protocol/LedgerHeader.h

@@ -72,4 +72,8 @@ deserializeHeader(Slice data, bool hasHash = false);
 LedgerHeader
 deserializePrefixedHeader(Slice data, bool hasHash = false);
 
+/** Calculate the hash of a ledger header. */
+uint256
+calculateLedgerHash(LedgerHeader const& info);
+
 }  // namespace xrpl

include/xrpl/protocol/Quality.h

@@ -56,8 +56,8 @@ struct TAmounts
         return *this;
     }
 
-    In in;
-    Out out;
+    In in{};
+    Out out{};
 };
 
 using Amounts = TAmounts<STAmount, STAmount>;
@@ -304,8 +304,8 @@ Quality::ceil_TAmounts_helper(
 
     // Use the existing STAmount implementation for now, but consider
     // replacing with code specific to IOUAMount and XRPAmount
-    Amounts stAmt(toSTAmount(amount.in), toSTAmount(amount.out));
-    STAmount stLim(toSTAmount(limit));
+    Amounts const stAmt(toSTAmount(amount.in), toSTAmount(amount.out));
+    STAmount const stLim(toSTAmount(limit));
     Amounts const stRes = ((*this).*ceil_function)(stAmt, stLim, roundUp...);
     return TAmounts<In, Out>(toAmount<In>(stRes.in), toAmount<Out>(stRes.out));
 }

include/xrpl/protocol/RippleLedgerHash.h

@@ -6,4 +6,4 @@ namespace xrpl {
 
 using LedgerHash = uint256;
 
-}
+}  // namespace xrpl

include/xrpl/protocol/STAmount.h

@@ -35,9 +35,9 @@ public:
 
 private:
     Asset mAsset;
-    mantissa_type mValue;
+    mantissa_type mValue{};
     exponent_type mOffset;
-    bool mIsNegative;
+    bool mIsNegative{};
 
 public:
     using value_type = STAmount;
@@ -532,7 +532,7 @@ STAmount::fromNumber(A const& a, Number const& number)
 {
     bool const negative = number.mantissa() < 0;
     Number const working{negative ? -number : number};
-    Asset asset{a};
+    Asset const asset{a};
     if (asset.integral())
     {
         std::uint64_t const intValue = static_cast<std::int64_t>(working);
@@ -716,7 +716,7 @@ roundToAsset(
     std::int32_t scale,
     Number::rounding_mode rounding = Number::getround())
 {
-    NumberRoundModeGuard mg(rounding);
+    NumberRoundModeGuard const mg(rounding);
     STAmount const ret{asset, value};
     if (ret.integral())
         return ret;

include/xrpl/protocol/STBase.h

@@ -83,7 +83,7 @@ to_json(T const& t)
 
 namespace detail {
 class STVar;
-}
+}  // namespace detail
 
 // VFALCO TODO fix this restriction on copy assignment.
 //

include/xrpl/protocol/STLedgerEntry.h

@@ -8,7 +8,7 @@ namespace xrpl {
 class Rules;
 namespace test {
 class Invariants_test;
-}
+}  // namespace test
 
 class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 {
@@ -86,7 +86,9 @@ inline STLedgerEntry::STLedgerEntry(LedgerEntryType type, uint256 const& key)
 {
 }
 
-inline STLedgerEntry::STLedgerEntry(SerialIter&& sit, uint256 const& index)
+inline STLedgerEntry::STLedgerEntry(
+    SerialIter&& sit,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
+    uint256 const& index)
     : STLedgerEntry(sit, index)
 {
 }

include/xrpl/protocol/STObject.h

@@ -671,7 +671,7 @@ public:
     OptionalProxy&
     operator=(std::nullopt_t const&);
     OptionalProxy&
-    operator=(optional_type&& v);
+    operator=(optional_type&& v);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
     OptionalProxy&
     operator=(optional_type const& v);
 
@@ -766,7 +766,7 @@ STObject::Proxy<T>::assign(U&& u)
         st_->makeFieldAbsent(*f_);
         return;
     }
-    T* t;
+    T* t = nullptr;
     if (style_ == soeINVALID)
         t = dynamic_cast<T*>(st_->getPField(*f_, true));
     else
@@ -851,7 +851,9 @@ STObject::OptionalProxy<T>::operator=(std::nullopt_t const&) -> OptionalProxy&
 
 template <class T>
 auto
-STObject::OptionalProxy<T>::operator=(optional_type&& v) -> OptionalProxy&
+STObject::OptionalProxy<T>::operator=(
+    optional_type&& v)  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
+    -> OptionalProxy&
 {
     if (v)
         this->assign(std::move(*v));
@@ -930,6 +932,7 @@ STObject::Transform::operator()(detail::STVar const& e) const
 
 //------------------------------------------------------------------------------
 
+// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
 inline STObject::STObject(SerialIter&& sit, SField const& name) : STObject(sit, name)
 {
 }
@@ -1153,7 +1156,7 @@ STObject::getFieldByValue(SField const& field) const
     if (!rf)
         throwFieldNotFound(field);
 
-    SerializedTypeID id = rf->getSType();
+    SerializedTypeID const id = rf->getSType();
 
     if (id == STI_NOTPRESENT)
         return V();  // optional field not present
@@ -1180,7 +1183,7 @@ STObject::getFieldByConstRef(SField const& field, V const& empty) const
     if (!rf)
         throwFieldNotFound(field);
 
-    SerializedTypeID id = rf->getSType();
+    SerializedTypeID const id = rf->getSType();
 
     if (id == STI_NOTPRESENT)
         return empty;  // optional field not present

include/xrpl/protocol/STTx.h

@@ -179,7 +179,8 @@ sterilize(STTx const& stx);
 bool
 isPseudoTx(STObject const& tx);
 
-inline STTx::STTx(SerialIter&& sit) : STTx(sit)
+inline STTx::STTx(SerialIter&& sit)  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
+    : STTx(sit)
 {
 }
 

include/xrpl/protocol/STVector256.h

@@ -69,9 +69,6 @@ public:
     std::vector<uint256>::iterator
     insert(std::vector<uint256>::const_iterator pos, uint256 const& value);
 
-    std::vector<uint256>::iterator
-    insert(std::vector<uint256>::const_iterator pos, uint256&& value);
-
     void
     push_back(uint256 const& v);
 
@@ -184,12 +181,6 @@ STVector256::insert(std::vector<uint256>::const_iterator pos, uint256 const& val
     return mValue.insert(pos, value);
 }
 
-inline std::vector<uint256>::iterator
-STVector256::insert(std::vector<uint256>::const_iterator pos, uint256&& value)
-{
-    return mValue.insert(pos, std::move(value));
-}
-
 inline void
 STVector256::push_back(uint256 const& v)
 {