Merge branch 'dev' into coverage-llm

# Conflicts:
#	.codecov.yml

.codecov.yml

@@ -19,6 +19,15 @@ coverage:
       default:
         target: auto
         threshold: 2%
+        paths:
+          # PeerImp is historically hard to exercise in the current unit-test
+          # harness. Keep this list narrow; new testable code should remain
+          # covered by the default patch gate.
+          - "!src/xrpld/overlay/detail/PeerImp.cpp"
+      historically-untested:
+        target: 0%
+        paths:
+          - "src/xrpld/overlay/detail/PeerImp.cpp"
     changes: false
 
 github_checks:

.github/actions/xahau-ga-dependencies/action.yml

@@ -50,6 +50,10 @@ inputs:
     options:
       - libstdcxx
       - libcxx
+  conan_deps_cxxflags:
+    description: 'Extra cxxflags applied to Conan dependency package builds only (NOT the rippled build). JSON object keyed by Conan package pattern, e.g. {"grpc/*":["-Wno-foo"]}. Maps to <pattern>:tools.build:cxxflags.'
+    required: false
+    default: '{}'
 
 outputs:
   cache-hit:
@@ -81,6 +85,8 @@ runs:
 
     - name: Configure Conan
       shell: bash
+      env:
+        CONAN_DEPS_CXXFLAGS: ${{ inputs.conan_deps_cxxflags }}
       run: |
         # Create the default profile directory if it doesn't exist
         mkdir -p ~/.conan2/profiles
@@ -105,7 +111,14 @@ runs:
         os=${{ inputs.os }}
         EOF
 
-        # Add buildenv and conf sections for Linux (not needed for macOS)
+        # [buildenv] + [conf] sections.
+        # Linux pins compiler executables; macOS uses the system toolchain.
+        # conan_deps_cxxflags (matrix-driven) optionally adds package-pattern
+        # scoped tools.build:cxxflags for Conan dependency builds only - typically
+        # grpc workarounds for newer clang's stricter diagnostics. Because these
+        # are profile-pattern scoped (e.g. grpc/*:...), they do NOT affect the
+        # consumer/rippled toolchain generated for the main build.
+        NEED_CONF=0
         if [ "${{ inputs.os }}" = "Linux" ] && [ -n "${{ inputs.cc }}" ]; then
           cat >> ~/.conan2/profiles/default <<EOF
 
@@ -116,16 +129,38 @@ runs:
         [conf]
         tools.build:compiler_executables={"c": "/usr/bin/${{ inputs.cc }}", "cpp": "/usr/bin/${{ inputs.cxx }}"}
         EOF
+          NEED_CONF=1
         fi
 
-        # Add macOS-specific conf if needed
-        if [ "${{ inputs.os }}" = "Macos" ]; then
-          cat >> ~/.conan2/profiles/default <<EOF
+        if [ -n "${CONAN_DEPS_CXXFLAGS}" ] && [ "${CONAN_DEPS_CXXFLAGS}" != "{}" ]; then
+          CONAN_DEPS_CXXFLAGS_LINES="$(python3 - <<'PY'
+        import json
+        import os
+        import sys
 
-        [conf]
-        # Workaround for gRPC with newer Apple Clang
-        tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
-        EOF
+        raw = os.environ["CONAN_DEPS_CXXFLAGS"]
+        data = json.loads(raw)
+        if not isinstance(data, dict):
+            sys.exit("conan_deps_cxxflags must be a JSON object like {\"grpc/*\": [\"-Wno-...\"]}")
+
+        for pattern, flags in data.items():
+            if not isinstance(pattern, str) or not pattern:
+                sys.exit("conan_deps_cxxflags keys must be non-empty Conan package patterns")
+            if pattern == "&":
+                sys.exit("conan_deps_cxxflags must target dependency package patterns, not the consumer (&)")
+            if not isinstance(flags, list) or not all(isinstance(flag, str) for flag in flags):
+                sys.exit(f"{pattern}: cxxflags must be a JSON string list")
+            if flags:
+                print(f"{pattern}:tools.build:cxxflags={json.dumps(flags, separators=(',', ':'))}")
+        PY
+          )"
+          if [ -n "${CONAN_DEPS_CXXFLAGS_LINES}" ] && [ "$NEED_CONF" = "0" ]; then
+            echo "" >> ~/.conan2/profiles/default
+            echo "[conf]" >> ~/.conan2/profiles/default
+          fi
+          if [ -n "${CONAN_DEPS_CXXFLAGS_LINES}" ]; then
+            printf '%s\n' "${CONAN_DEPS_CXXFLAGS_LINES}" >> ~/.conan2/profiles/default
+          fi
         fi
 
         # Display profile for verification

.github/workflows/xahau-ga-macos.yml

@@ -107,6 +107,9 @@ jobs:
           compiler: apple-clang
           compiler_version: ${{ steps.detect-compiler.outputs.compiler_version }}
           stdlib: libcxx
+          # grpc 1.50.1 trips clang-19+ -Werror=missing-template-arg-list-after-template-kw
+          # on Apple Clang. Drop when grpc is bumped past the fix.
+          conan_deps_cxxflags: '{"grpc/*":["-Wno-missing-template-arg-list-after-template-kw"]}'
 
       - name: Build
         uses: ./.github/actions/xahau-ga-build

.github/workflows/xahau-ga-nix.yml

@@ -72,15 +72,26 @@ jobs:
                   "job_type": "build"
               },
               {
-                  "compiler_id": "gcc-13-libstdcxx",
-                  "compiler": "gcc",
-                  "cc": "gcc-13",
-                  "cxx": "g++-13",
-                  "gcov": "gcov-13",
-                  "compiler_version": 13,
-                  "stdlib": "default",
+                  # Latest stable Clang for the most accurate source-based
+                  # coverage mapping (newer language features, fewer bugs in
+                  # llvm-cov region inference). Pulled from apt.llvm.org since
+                  # Ubuntu 24.04 default repos cap at clang-18.
+                  "compiler_id": "clang-20-libcxx",
+                  "compiler": "clang",
+                  "cc": "clang-20",
+                  "cxx": "clang++-20",
+                  "compiler_version": 20,
+                  "stdlib": "libcxx",
                   "configuration": "Debug",
-                  "job_type": "coverage"
+                  "job_type": "coverage",
+                  "coverage_tool": "llvm",
+                  "coverage_format": "lcov",
+                  # grpc 1.50.1 uses `Foo::template Bar(...)` without an
+                  # angle-bracket arg list; clang-19+ promoted that to
+                  # -Werror. Drop when grpc is bumped past the fix.
+                  "conan_deps_cxxflags": {
+                      "grpc/*": ["-Wno-missing-template-arg-list-after-template-kw"]
+                  }
               },
               {
                   "compiler_id": "clang-14-libstdcxx-gcc11",
@@ -131,7 +142,7 @@ jobs:
           # Minimal matrix for PRs and feature branches
           minimal_matrix = [
               full_matrix[1],  # gcc-13 (middle-ground gcc)
-              full_matrix[2],  # gcc-13 coverage
+              full_matrix[2],  # clang-20 llvm-cov coverage
               full_matrix[3]   # clang-14 (mature, stable clang)
           ]
           
@@ -207,9 +218,9 @@ jobs:
           # Select the appropriate matrix
           if use_full:
               if force_full:
-                  print(f"Using FULL matrix (7 configs) - forced by [ci-nix-full-matrix] tag")
+                  print(f"Using FULL matrix (7 configs (build x6 + clang-20 llvm-cov coverage)) - forced by [ci-nix-full-matrix] tag")
               else:
-                  print(f"Using FULL matrix (7 configs) - targeting main branch")
+                  print(f"Using FULL matrix (7 configs (build x6 + clang-20 llvm-cov coverage)) - targeting main branch")
               matrix = full_matrix
           else:
               print(f"Using MINIMAL matrix (3 configs) - feature branch/PR")
@@ -257,9 +268,25 @@ jobs:
 
       - name: Install build dependencies
         run: |
+          # Bump apt's default 3 retries; papers over short upstream blips
+          # like the recurring ppa.launchpadcontent.net outages.
+          echo 'Acquire::Retries "5";' > /etc/apt/apt.conf.d/80-retries
           apt-get update
           apt-get install -y software-properties-common
           add-apt-repository ppa:ubuntu-toolchain-r/test -y
+
+          # apt.llvm.org for Clang versions newer than what Ubuntu 24.04 ships
+          # (24.04 default repos cap at clang-18). The bootstrap script adds
+          # the LLVM apt source for the requested version and runs apt-get update.
+          if [ "${{ matrix.compiler }}" = "clang" ] && [ "${{ matrix.compiler_version }}" -ge 19 ]; then
+            apt-get install -y wget gnupg lsb-release
+            wget -qO /tmp/llvm.sh https://apt.llvm.org/llvm.sh
+            chmod +x /tmp/llvm.sh
+            # `all` installs clang + libllvm + lldb + lld + the llvm-N package
+            # (which provides llvm-profdata-N / llvm-cov-N for coverage runs).
+            /tmp/llvm.sh ${{ matrix.compiler_version }} all
+          fi
+
           apt-get update
           apt-get install -y git python3 python-is-python3 pipx
           pipx ensurepath
@@ -332,10 +359,16 @@ jobs:
           pipx install "conan>=2.0,<3"
           echo "$HOME/.local/bin" >> $GITHUB_PATH
 
-          # Install gcovr for coverage jobs
+          # Install coverage tooling
           if [ "${{ matrix.job_type }}" = "coverage" ]; then
-            pipx install "gcovr>=7,<9"
             apt-get install -y curl lcov
+            if [ "${{ matrix.coverage_tool }}" = "llvm" ]; then
+              # Native LLVM source-based coverage: llvm-profdata + llvm-cov.
+              # The clang-N package doesn't pull these in; the llvm-N package does.
+              apt-get install -y "llvm-${{ matrix.compiler_version }}"
+            else
+              pipx install "gcovr>=7,<9"
+            fi
           fi
 
       - name: Check environment
@@ -348,10 +381,15 @@ jobs:
           which ${{ matrix.cxx }} && ${{ matrix.cxx }} --version || echo "${{ matrix.cxx }} not found"
           which ccache && ccache --version || echo "ccache not found"
 
-          # Check gcovr for coverage jobs
+          # Check coverage tooling
           if [ "${{ matrix.job_type }}" = "coverage" ]; then
-            which gcov && gcov --version || echo "gcov not found"
-            which gcovr && gcovr --version || echo "gcovr not found"
+            if [ "${{ matrix.coverage_tool }}" = "llvm" ]; then
+              which "llvm-profdata-${{ matrix.compiler_version }}" && "llvm-profdata-${{ matrix.compiler_version }}" --version || echo "llvm-profdata not found"
+              which "llvm-cov-${{ matrix.compiler_version }}" && "llvm-cov-${{ matrix.compiler_version }}" --version || echo "llvm-cov not found"
+            else
+              which gcov && gcov --version || echo "gcov not found"
+              which gcovr && gcovr --version || echo "gcovr not found"
+            fi
           fi
 
           echo "---- Full Environment ----"
@@ -378,6 +416,7 @@ jobs:
           cc: ${{ matrix.cc }}
           cxx: ${{ matrix.cxx }}
           stdlib: ${{ matrix.stdlib }}
+          conan_deps_cxxflags: ${{ matrix.conan_deps_cxxflags && toJson(matrix.conan_deps_cxxflags) || '{}' }}
           gha_cache_enabled: 'false' # Disable caching for self hosted runner
 
       - name: Build
@@ -410,8 +449,9 @@ jobs:
           cache_version: ${{ env.CACHE_VERSION }}
           main_branch: ${{ env.MAIN_BRANCH_NAME }}
           stdlib: ${{ matrix.stdlib }}
-          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
-          cmake-args: '-Dcoverage=ON -Dcoverage_format=xml -Dcoverage_test_parallelism=$(($(nproc)/2)) -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_CXX_FLAGS="-O0" -DCMAKE_C_FLAGS="-O0"'
+          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness.
+          # Use *_FLAGS_DEBUG so the build action's stdlib flag (e.g. -stdlib=libc++) in CMAKE_CXX_FLAGS isn't clobbered.
+          cmake-args: '-Dcoverage=ON -Dcoverage_tool=${{ matrix.coverage_tool }} -Dcoverage_format=${{ matrix.coverage_format }} -Dcoverage_test_parallelism=$(($(nproc)/2)) -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_CXX_FLAGS_DEBUG="-g -O0" -DCMAKE_C_FLAGS_DEBUG="-g -O0"'
           cmake-target: 'coverage'
           ccache_max_size: '100G'
 
@@ -443,22 +483,26 @@ jobs:
       - name: Move coverage report
         if: matrix.job_type == 'coverage'
         shell: bash
+        env:
+          COVERAGE_FILE: ${{ matrix.coverage_tool == 'llvm' && 'coverage.lcov' || 'coverage.xml' }}
         run: |
-          mv "${{ env.build_dir }}/coverage.xml" ./
+          mv "${{ env.build_dir }}/${COVERAGE_FILE}" ./
+          echo "COVERAGE_FILE=${COVERAGE_FILE}" >> "$GITHUB_ENV"
 
       - name: Archive coverage report
         if: matrix.job_type == 'coverage'
         uses: actions/upload-artifact@v4
         with:
-          name: coverage.xml
-          path: coverage.xml
+          name: ${{ env.COVERAGE_FILE }}-${{ matrix.compiler_id }}
+          path: ${{ env.COVERAGE_FILE }}
           retention-days: 30
 
       - name: Upload coverage report
         if: matrix.job_type == 'coverage'
         uses: codecov/codecov-action@v5
         with:
-          files: coverage.xml
+          files: ${{ env.COVERAGE_FILE }}
+          flags: ${{ matrix.coverage_tool }}
           fail_ci_if_error: true
           disable_search: true
           verbose: true

build-core.sh

@@ -55,8 +55,10 @@ sed -i s/\"0.0.0\"/\"$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abb
 conan export external/snappy --version 1.1.10 --user xahaud --channel stable &&
 conan export external/soci --version 4.0.3 --user xahaud --channel stable &&
 cd release-build &&
-# Install dependencies. The Conan profile tags package_ids with the glibc
-# baseline, so tools like b2/protoc are built locally instead of downloaded.
+# Install dependencies - tool_requires in conanfile.py handles glibc 2.28 compatibility
+# for build tools (protoc, grpc plugins, b2) in HBB environment
+# The tool_requires('b2/5.3.2') in conanfile.py should force b2 to build from source
+# with the correct toolchain, avoiding the GLIBCXX_3.4.29 issue
 echo "=== Installing dependencies ===" &&
 conan install .. --output-folder . --build missing --settings build_type=$BUILD_TYPE \
   -o with_wasmedge=False -o tool_requires_b2=True &&
@@ -76,10 +78,8 @@ strip -s rippled &&
 mv rippled xahaud &&
 echo "=== Full ldd output ===" &&
 ldd xahaud &&
-echo "=== Checking GLIBC requirement (must be <= 2.28) ===" &&
-GLIBC_MAX=$(objdump -T xahaud | grep -o 'GLIBC_[0-9.]*' | sort -uV | tail -1) &&
-echo "Max required: $GLIBC_MAX" &&
-[ "$(printf '%s\n' GLIBC_2.28 "$GLIBC_MAX" | sort -V | tail -1)" = "GLIBC_2.28" ] &&
+echo "=== Running libcheck ===" &&
+libcheck xahaud &&
 echo "Build host: `hostname`" > release.info &&
 echo "Build date: `date`" >> release.info &&
 echo "Build md5: `md5sum xahaud`" >> release.info &&
@@ -88,11 +88,9 @@ git remote -v >> release.info &&
 echo "Git status:" >> release.info &&
 git status -v >> release.info &&
 echo "Git log [last 20]:" >> release.info &&
-git log -n 20 >> release.info || BUILD_FAILED=1
+git log -n 20 >> release.info;
 
-if [[ -n "${BUILD_FAILED:-}" ]]; then
-  echo "ERR build failed, not publishing"
-elif [[ "$4" == "" ]]; then
+if [[ "$4" == "" ]]; then
   # Non GH, local building
   echo "Non GH, local building, no Action runner magic"
 else
@@ -111,7 +109,7 @@ else
   echo $(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
 fi
 
-cd /io;
+cd ..;
 
 mv src/xrpld/net/detail/RegisterSSLCerts.cpp.old src/xrpld/net/detail/RegisterSSLCerts.cpp;
 mv cmake/deps/WasmEdge.old cmake/deps/WasmEdge.cmake;
@@ -119,5 +117,3 @@ rm src/certs/certbundle.h;
 git checkout src/libxrpl/protocol/BuildInfo.cpp;
 
 echo "END INSIDE CONTAINER - CORE"
-
-[[ -z "${BUILD_FAILED:-}" ]] || exit 1

build-full.sh

@@ -64,7 +64,7 @@ if [ "$(grep certbundle.h src/xrpld/net/detail/RegisterSSLCerts.cpp | wc -l)" -e
     sed -i "s/#include <xrpld\/net\/RegisterSSLCerts.h>/\0\n#include <certs\/certbundle.h>/g" src/xrpld/net/detail/RegisterSSLCerts.cpp
 fi
 # Environment setup moved to Dockerfile in release-builder.sh
-source /opt/rh/gcc-toolset-13/enable
+source /opt/rh/gcc-toolset-11/enable
 export PATH=/usr/local/bin:$PATH
 export CC='/usr/lib64/ccache/gcc' &&
   export CXX='/usr/lib64/ccache/g++' &&

cmake/CodeCoverageLLVM.cmake

@@ -0,0 +1,156 @@
+#[===================================================================[
+  Native LLVM source-based code coverage helper.
+
+  Drives the -fprofile-instr-generate / -fcoverage-mapping pipeline:
+    1. Run instrumented binary with LLVM_PROFILE_FILE=...%m-%p.profraw
+    2. llvm-profdata merge -sparse  -> coverage.profdata
+    3. llvm-cov export/show/report  -> final report
+
+  Output filename per coverage_format:
+    lcov              -> coverage.lcov
+    json              -> coverage.json
+    txt | text        -> coverage.txt
+    html | html-details -> <NAME>/index.html
+#]===================================================================]
+
+include(CMakeParseArguments)
+
+# Locate llvm-profdata / llvm-cov, preferring versioned variants matching the
+# Clang we're building with so we don't accidentally pair clang-20 with
+# llvm-cov-14 (profile format mismatch -> hard failure).
+function(_find_llvm_cov_tools)
+  if(LLVM_PROFDATA_PATH AND LLVM_COV_PATH)
+    return()
+  endif()
+
+  string(REGEX MATCH "^[0-9]+" _major "${CMAKE_CXX_COMPILER_VERSION}")
+
+  set(_pd_names llvm-profdata)
+  set(_cov_names llvm-cov)
+  if(_major)
+    list(PREPEND _pd_names "llvm-profdata-${_major}")
+    list(PREPEND _cov_names "llvm-cov-${_major}")
+  endif()
+
+  # Only delegate to xcrun when the *compiler* is AppleClang. On macOS with
+  # Homebrew/system clang-N, xcrun would resolve to Xcode's llvm tools which
+  # could be a different version - exactly the mismatch we want to avoid.
+  if(APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+    execute_process(COMMAND xcrun -f llvm-profdata
+      OUTPUT_VARIABLE _pd_xcrun OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_QUIET RESULT_VARIABLE _pd_rc)
+    if(_pd_rc EQUAL 0 AND _pd_xcrun)
+      set(LLVM_PROFDATA_PATH "${_pd_xcrun}" CACHE FILEPATH "llvm-profdata" FORCE)
+    endif()
+    execute_process(COMMAND xcrun -f llvm-cov
+      OUTPUT_VARIABLE _cov_xcrun OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_QUIET RESULT_VARIABLE _cov_rc)
+    if(_cov_rc EQUAL 0 AND _cov_xcrun)
+      set(LLVM_COV_PATH "${_cov_xcrun}" CACHE FILEPATH "llvm-cov" FORCE)
+    endif()
+  endif()
+
+  if(NOT LLVM_PROFDATA_PATH)
+    find_program(LLVM_PROFDATA_PATH NAMES ${_pd_names})
+  endif()
+  if(NOT LLVM_COV_PATH)
+    find_program(LLVM_COV_PATH NAMES ${_cov_names})
+  endif()
+endfunction()
+
+function(setup_target_for_coverage_llvm)
+  set(oneValueArgs NAME FORMAT)
+  set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+  cmake_parse_arguments(Cov "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  _find_llvm_cov_tools()
+  if(NOT LLVM_PROFDATA_PATH)
+    message(FATAL_ERROR "llvm-profdata not found (needed for coverage_tool=llvm)")
+  endif()
+  if(NOT LLVM_COV_PATH)
+    message(FATAL_ERROR "llvm-cov not found (needed for coverage_tool=llvm)")
+  endif()
+
+  if(NOT Cov_FORMAT)
+    set(Cov_FORMAT lcov)
+  endif()
+
+  set(_profraw_dir "${PROJECT_BINARY_DIR}/${Cov_NAME}-profraw")
+  set(_profdata    "${PROJECT_BINARY_DIR}/${Cov_NAME}.profdata")
+
+  # Resolve binary path: accept either an absolute path or a bare target name
+  # (resolved against PROJECT_BINARY_DIR). Splice the resolved path back into
+  # Cov_EXECUTABLE so the run command invokes it via absolute path - bare
+  # names aren't on PATH and the build dir isn't `.` either.
+  list(GET Cov_EXECUTABLE 0 _exec_name)
+  if(IS_ABSOLUTE "${_exec_name}")
+    set(_binary "${_exec_name}")
+  else()
+    set(_binary "${PROJECT_BINARY_DIR}/${_exec_name}")
+    list(REMOVE_AT Cov_EXECUTABLE 0)
+    list(PREPEND Cov_EXECUTABLE "${_binary}")
+  endif()
+
+  # llvm-cov takes a single -ignore-filename-regex; OR our excludes together.
+  set(_ignore_regex "")
+  foreach(EXC IN LISTS Cov_EXCLUDE)
+    if(_ignore_regex)
+      string(APPEND _ignore_regex "|")
+    endif()
+    string(APPEND _ignore_regex "${EXC}")
+  endforeach()
+  set(_filter "")
+  if(_ignore_regex)
+    set(_filter "-ignore-filename-regex='${_ignore_regex}'")
+  endif()
+
+  # Pick llvm-cov subcommand + output file for the requested format. Each
+  # branch builds a single shell command string that we'll hand to bash -c.
+  if(Cov_FORMAT STREQUAL "lcov")
+    set(_output "${PROJECT_BINARY_DIR}/coverage.lcov")
+    set(_report_sh "${LLVM_COV_PATH} export -instr-profile='${_profdata}' -format=lcov ${_filter} '${_binary}' > '${_output}'")
+  elseif(Cov_FORMAT STREQUAL "json")
+    set(_output "${PROJECT_BINARY_DIR}/coverage.json")
+    set(_report_sh "${LLVM_COV_PATH} export -instr-profile='${_profdata}' -format=text ${_filter} '${_binary}' > '${_output}'")
+  elseif(Cov_FORMAT STREQUAL "txt" OR Cov_FORMAT STREQUAL "text")
+    set(_output "${PROJECT_BINARY_DIR}/coverage.txt")
+    set(_report_sh "${LLVM_COV_PATH} report -instr-profile='${_profdata}' ${_filter} '${_binary}' > '${_output}'")
+  elseif(Cov_FORMAT STREQUAL "html" OR Cov_FORMAT STREQUAL "html-details")
+    set(_output "${PROJECT_BINARY_DIR}/${Cov_NAME}/index.html")
+    set(_report_sh "${LLVM_COV_PATH} show -instr-profile='${_profdata}' -format=html -output-dir='${PROJECT_BINARY_DIR}/${Cov_NAME}' ${_filter} '${_binary}'")
+  else()
+    message(FATAL_ERROR "coverage_tool=llvm: unsupported coverage_format '${Cov_FORMAT}' (use lcov|json|txt|html)")
+  endif()
+
+  set(_merge_sh "${LLVM_PROFDATA_PATH} merge -sparse -o '${_profdata}' '${_profraw_dir}'/*.profraw")
+
+  if(CODE_COVERAGE_VERBOSE)
+    message(STATUS "[coverage:llvm] binary:   ${_binary}")
+    message(STATUS "[coverage:llvm] profraw:  ${_profraw_dir}")
+    message(STATUS "[coverage:llvm] profdata: ${_profdata}")
+    message(STATUS "[coverage:llvm] format:   ${Cov_FORMAT}")
+    message(STATUS "[coverage:llvm] output:   ${_output}")
+    if(_ignore_regex)
+      message(STATUS "[coverage:llvm] ignore:   ${_ignore_regex}")
+    endif()
+    message(STATUS "[coverage:llvm] merge:    ${_merge_sh}")
+    message(STATUS "[coverage:llvm] report:   ${_report_sh}")
+  endif()
+
+  # %m: hash of the binary, %p: pid. Wipe the dir up front so stale profraw
+  # files can't leak into a fresh merge.
+  add_custom_target(${Cov_NAME}
+    COMMAND ${CMAKE_COMMAND} -E rm -rf "${_profraw_dir}"
+    COMMAND ${CMAKE_COMMAND} -E make_directory "${_profraw_dir}"
+    COMMAND ${CMAKE_COMMAND} -E env
+        "LLVM_PROFILE_FILE=${_profraw_dir}/rippled-%m-%p.profraw"
+        ${Cov_EXECUTABLE} ${Cov_EXECUTABLE_ARGS}
+    COMMAND bash -c "${_merge_sh}"
+    COMMAND bash -c "${_report_sh}"
+    BYPRODUCTS ${_output}
+    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    DEPENDS ${Cov_DEPENDENCIES}
+    VERBATIM
+    COMMENT "Running llvm-cov (${Cov_FORMAT}) -> ${_output}"
+  )
+endfunction()

cmake/RippledCov.cmake

@@ -11,6 +11,21 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   return()
 endif()
 
+if(coverage_tool STREQUAL "llvm")
+  include(CodeCoverageLLVM)
+
+  setup_target_for_coverage_llvm(
+    NAME coverage
+    FORMAT ${coverage_format}
+    EXECUTABLE rippled
+    EXECUTABLE_ARGS --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --unittest-jobs ${coverage_test_parallelism} --quiet --unittest-log
+    EXCLUDE "src/test" "include/xrpl/beast/test" "include/xrpl/beast/unit_test" "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+    DEPENDENCIES rippled
+  )
+  return()
+endif()
+
+# coverage_tool == "gcov" (default): existing gcovr-driven pipeline.
 include(CodeCoverage)
 
 # The instructions for these commands come from the `CodeCoverage` module,

cmake/RippledInterface.cmake

@@ -28,15 +28,17 @@ target_compile_options (opts
     $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
     $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
     $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},llvm>>:-g -fprofile-instr-generate -fcoverage-mapping>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},llvm>>:-g -fprofile-instr-generate -fcoverage-mapping>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 

cmake/RippledSettings.cmake

@@ -29,13 +29,25 @@ if(is_gcc OR is_clang)
     "Unit tests parallelism for the purpose of coverage report.")
   set(coverage_format "html-details" CACHE STRING
     "Output format of the coverage report.")
+  set(coverage_tool "gcov" CACHE STRING
+    "Coverage instrumentation tool: 'gcov' (default, gcc/clang via --coverage + gcovr) or 'llvm' (clang only, native source-based coverage via -fprofile-instr-generate).")
+  set_property(CACHE coverage_tool PROPERTY STRINGS "gcov" "llvm")
+  if(NOT coverage_tool MATCHES "^(gcov|llvm)$")
+    message(FATAL_ERROR "coverage_tool must be 'gcov' or 'llvm', got '${coverage_tool}'")
+  endif()
   set(coverage_extra_args "" CACHE STRING
-    "Additional arguments to pass to gcovr.")
+    "Additional arguments to pass to gcovr (gcov tool only).")
   set(coverage_test "" CACHE STRING
     "On gcc & clang, the specific unit test(s) to run for coverage. Default is all tests.")
   if(coverage_test AND NOT coverage)
     set(coverage ON CACHE BOOL "gcc/clang only" FORCE)
   endif()
+  # Validate after coverage_test may have flipped coverage on, otherwise
+  # `-Dcoverage_tool=llvm -Dcoverage_test=Foo` on gcc would silently slip
+  # past the Clang guard and produce a broken instrumentation combo.
+  if(coverage AND coverage_tool STREQUAL "llvm" AND NOT is_clang)
+    message(FATAL_ERROR "coverage_tool=llvm requires Clang (got ${CMAKE_CXX_COMPILER_ID})")
+  endif()
   option(wextra "compile with extra gcc/clang warnings enabled" ON)
 else()
   set(profile OFF CACHE BOOL "gcc/clang only" FORCE)

include/xrpl/protocol/jss.h

@@ -292,9 +292,7 @@ JSS(duration_us);             // out: NetworkOPs
 JSS(effective);               // out: ValidatorList
                               // in: UNL
 JSS(elapsed_seconds);
-JSS(enabled);                // out: AmendmentTable (on-ledger);
-                             //      ServerDefinitions (this server)
-JSS(ledger_enabled);         // out: ServerDefinitions (on-ledger)
+JSS(enabled);                // out: AmendmentTable
 JSS(engine_result);          // out: NetworkOPs, TransactionSign, Submit
 JSS(engine_result_code);     // out: NetworkOPs, TransactionSign, Submit
 JSS(engine_result_message);  // out: NetworkOPs, TransactionSign, Submit

release-builder.sh

@@ -12,12 +12,10 @@ echo "Cleaning previously built binary"
 rm -f release-build/xahaud
 
 BUILD_CORES=$(echo "scale=0 ; $(nproc) / 1.337" | bc)
-OUT_DIR="/data/builds"
 
 if [[ "$GITHUB_REPOSITORY" == "" ]]; then
   #Default
   BUILD_CORES=${BUILD_CORES:-8}
-  OUT_DIR="./data/builds"
 fi
 
 # Ensure still works outside of GH Actions by setting these to /dev/null
@@ -53,7 +51,7 @@ CACHE_VOLUME_NAME="xahau-release-builder-cache"
 if false; then
   echo "Static container, execute in static container to have max. cache"
   docker start $CONTAINER_NAME
-  docker exec -i $CONTAINER_NAME bash -c "source /opt/rh/gcc-toolset-13/enable && bash -x /io/build-core.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
+  docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-core.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
   docker stop $CONTAINER_NAME
 else
   echo "No static container, build on temp container"
@@ -65,32 +63,24 @@ else
   # Create inline Dockerfile with environment setup for build-full.sh
   DOCKERFILE_CONTENT=$(
     cat <<'DOCKERFILE_EOF'
-FROM --platform=linux/amd64 almalinux:8
+FROM ghcr.io/phusion/holy-build-box:4.0.1-amd64
 
 ARG BUILD_CORES=8
 
-# AlmaLinux 8 keeps the glibc 2.28 baseline (same as holy-build-box 4).
-# The devel repo (disabled by default, like in holy-build-box) provides ncurses-static.
-# - gcc-toolset-13: compiler for xahaud itself and its Conan dependencies
-# - gcc-toolset-11: used only for the pre-built LLD/WasmEdge below (known-good);
-#   their static libs are linked into the gcc-13 build with -static-libstdc++
-RUN dnf install -y dnf-plugins-core epel-release && \
-    dnf config-manager --set-enabled powertools && \
-    printf "%s\n" "[devel]" "name=AlmaLinux 8 - Devel" \
-        "baseurl=https://repo.almalinux.org/almalinux/8/devel/\$basearch/os/" \
-        "gpgcheck=1" "gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-AlmaLinux" "enabled=0" \
-        > /etc/yum.repos.d/almalinux-devel.repo && \
+# Enable repositories and install dependencies
+RUN /hbb_exe/activate-exec bash -c "dnf install -y epel-release && \
+    dnf config-manager --set-enabled powertools || dnf config-manager --set-enabled crb && \
     dnf install -y --enablerepo=devel \
-        wget git unzip xz perl hostname make \
-        gcc-toolset-11-gcc-c++ gcc-toolset-11-binutils \
-        gcc-toolset-13-gcc-c++ gcc-toolset-13-binutils gcc-toolset-13-libatomic-devel \
+        wget git \
+        gcc-toolset-11-gcc-c++ gcc-toolset-11-binutils gcc-toolset-11-libatomic-devel \
         lz4 lz4-devel \
         ncurses-static ncurses-devel \
         snappy snappy-devel \
         zlib zlib-devel zlib-static \
-        sqlite-devel \
-        python3.11 python3.11-pip \
+        libasan \
+        python3 python3-pip \
         ccache \
+        ninja-build \
         mold \
         patch \
         glibc-devel glibc-static \
@@ -100,15 +90,16 @@ RUN dnf install -y dnf-plugins-core epel-release && \
         texinfo \
         libtool \
         llvm14-static llvm14-devel && \
-    dnf clean all
+    dnf clean all"
 
 # Install Conan 2 and CMake
-RUN python3.11 -m pip install "conan>=2.0,<3.0" "ninja>=1.13,<1.14" && \
-    wget -q https://github.com/Kitware/CMake/releases/download/v3.25.3/cmake-3.25.3-linux-x86_64.tar.gz -O cmake.tar.gz && \
-    tar -xzf cmake.tar.gz --strip-components=1 -C /usr/local && \
+RUN /hbb_exe/activate-exec pip3 install "conan>=2.0,<3.0" && \
+    /hbb_exe/activate-exec wget -q https://github.com/Kitware/CMake/releases/download/v3.25.3/cmake-3.25.3-linux-x86_64.tar.gz -O cmake.tar.gz && \
+    mkdir cmake && \
+    tar -xzf cmake.tar.gz --strip-components=1 -C cmake && \
     rm cmake.tar.gz
 
-# Dual Boost configuration:
+# Dual Boost configuration in HBB environment:
 # - Manual Boost in /usr/local (minimal: for WasmEdge which is pre-built in Docker)
 # - Conan Boost (full: for the application and all dependencies via toolchain)
 #
@@ -118,8 +109,7 @@ RUN python3.11 -m pip install "conan>=2.0,<3.0" "ninja>=1.13,<1.14" && \
 #   - link=static: Creates static Boost libraries (.a files) instead of shared (.so files)
 #   - runtime-link=shared: Links Boost libraries against shared libc (glibc)
 # WasmEdge only needs boost::filesystem and boost::system
-RUN echo 'Boost cache bust: v5-minimal' && \
-    source /opt/rh/gcc-toolset-11/enable && \
+RUN /hbb_exe/activate-exec bash -c "echo 'Boost cache bust: v5-minimal' && \
     rm -rf /usr/local/lib/libboost* /usr/local/include/boost && \
     cd /tmp && \
     wget -q https://archives.boost.io/release/1.86.0/source/boost_1_86_0.tar.gz -O boost.tar.gz && \
@@ -131,7 +121,7 @@ RUN echo 'Boost cache bust: v5-minimal' && \
         link=static runtime-link=shared -j${BUILD_CORES} \
         --with-filesystem --with-system && \
     cd /tmp && \
-    rm -rf boost boost.tar.gz
+    rm -rf boost boost.tar.gz"
 
 ENV CMAKE_EXE_LINKER_FLAGS="-static-libstdc++"
 
@@ -142,7 +132,7 @@ ENV CC='ccache gcc'
 ENV CXX='ccache g++'
 
 # Install LLD
-RUN source /opt/rh/gcc-toolset-11/enable && \
+RUN /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && \
     cd /tmp && \
     wget -q https://github.com/llvm/llvm-project/releases/download/llvmorg-14.0.3/lld-14.0.3.src.tar.xz && \
     wget -q https://github.com/llvm/llvm-project/releases/download/llvmorg-14.0.3/libunwind-14.0.3.src.tar.xz && \
@@ -155,11 +145,11 @@ RUN source /opt/rh/gcc-toolset-11/enable && \
         -DLLVM_LIBRARY_DIR=/usr/lib64/llvm14/lib/ \
         -DCMAKE_INSTALL_PREFIX=/usr/lib64/llvm14/ \
         -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_EXE_LINKER_FLAGS="$CMAKE_EXE_LINKER_FLAGS" && \
+        -DCMAKE_EXE_LINKER_FLAGS=\"\$CMAKE_EXE_LINKER_FLAGS\" && \
     make -j${BUILD_CORES} install && \
     ln -s /usr/lib64/llvm14/lib/include/lld /usr/include/lld && \
     cp /usr/lib64/llvm14/lib/liblld*.a /usr/local/lib/ && \
-    cd /tmp && rm -rf lld-* libunwind-*
+    cd /tmp && rm -rf lld-* libunwind-*"
 
 # Build and install WasmEdge (static version)
 # Note: Conan only provides WasmEdge with shared library linking.
@@ -173,7 +163,7 @@ RUN cd /tmp && \
     cd WasmEdge-0.11.2 && \
     ( mkdir -p build; echo "" ) && \
     cd build && \
-    source /opt/rh/gcc-toolset-11/enable && \
+    /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && \
     ln -sf /opt/rh/gcc-toolset-11/root/usr/bin/ar /usr/bin/ar && \
     ln -sf /opt/rh/gcc-toolset-11/root/usr/bin/ranlib /usr/bin/ranlib && \
     echo '=== Binutils version check ===' && \
@@ -191,9 +181,9 @@ RUN cd /tmp && \
         -DWASMEDGE_BUILD_PLUGINS=OFF \
         -DWASMEDGE_LINK_TOOLS_STATIC=ON \
         -DBoost_NO_BOOST_CMAKE=ON \
-        -DCMAKE_EXE_LINKER_FLAGS="$CMAKE_EXE_LINKER_FLAGS" \
+        -DCMAKE_EXE_LINKER_FLAGS=\"\$CMAKE_EXE_LINKER_FLAGS\" \
         && \
-    make -j${BUILD_CORES} install && \
+    make -j${BUILD_CORES} install" && \
     cp -r include/api/wasmedge /usr/include/ && \
     cd /tmp && rm -rf WasmEdge* 0.11.2.zip
 
@@ -202,7 +192,7 @@ ENV PATH=/usr/local/bin:$PATH
 
 # Configure ccache and Conan 2
 # NOTE: Using echo commands instead of heredocs because heredocs in Docker RUN commands are finnicky
-RUN ccache -M 100G && \
+RUN /hbb_exe/activate-exec bash -c "ccache -M 100G && \
     ccache -o cache_dir=/cache/ccache && \
     ccache -o compiler_check=content && \
     ccache -o direct_mode=true && \
@@ -217,23 +207,14 @@ RUN ccache -M 100G && \
     echo 'compiler=gcc' >> ~/.conan2/profiles/default && \
     echo 'compiler.cppstd=20' >> ~/.conan2/profiles/default && \
     echo 'compiler.libcxx=libstdc++11' >> ~/.conan2/profiles/default && \
-    echo 'compiler.version=13' >> ~/.conan2/profiles/default && \
+    echo 'compiler.version=11' >> ~/.conan2/profiles/default && \
     echo 'os=Linux' >> ~/.conan2/profiles/default && \
     echo '' >> ~/.conan2/profiles/default && \
     echo '[conf]' >> ~/.conan2/profiles/default && \
     echo '# Force building from source for packages with binary compatibility issues' >> ~/.conan2/profiles/default && \
     echo '*:tools.system.package_manager:mode=build' >> ~/.conan2/profiles/default && \
-    echo '# Tag every package_id with the glibc baseline so ConanCenter binaries (built on a' >> ~/.conan2/profiles/default && \
-    echo '# newer glibc, e.g. protoc/b2) never match; everything is built locally and cached' >> ~/.conan2/profiles/default && \
-    echo 'user.xahaud:glibc=2.28' >> ~/.conan2/profiles/default && \
-    echo 'tools.info.package_id:confs=["user.xahaud:glibc"]' >> ~/.conan2/profiles/default && \
-    echo "" >> ~/.conan2/profiles/default && \
-    echo "# ninja is provided by pip (manylinux wheel); building it in Conan hits a gcc-13 LTO ICE" >> ~/.conan2/profiles/default && \
-    echo "[platform_tool_requires]" >> ~/.conan2/profiles/default && \
-    echo "ninja/1.13.2" >> ~/.conan2/profiles/default && \
-    ln -sf ../../bin/ccache /usr/lib64/ccache/gcc && \
-    ln -sf ../../bin/ccache /usr/lib64/ccache/g++ && \
-    ln -sf ../../bin/ccache /usr/lib64/ccache/c++
+    ln -s ../../bin/ccache /usr/lib64/ccache/g++ && \
+    ln -s ../../bin/ccache /usr/lib64/ccache/c++"
 
 DOCKERFILE_EOF
   )
@@ -246,15 +227,15 @@ DOCKERFILE_EOF
   if [[ "$GITHUB_REPOSITORY" == "" ]]; then
     # Non GH, local building
     echo "Non-GH runner, local building, temp container"
-    docker run -i --user 0:$(id -g) --rm -v $OUT_DIR:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" bash -c "source /opt/rh/gcc-toolset-13/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
+    docker run -i --user 0:$(id -g) --rm -v /data/builds:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
   else
     # GH Action, runner
     echo "GH Action, runner, clean & re-create create persistent container"
     docker rm -f $CONTAINER_NAME
     echo "echo 'Stopping container: $CONTAINER_NAME'" >>"$JOB_CLEANUP_SCRIPT"
     echo "docker stop --time=15 \"$CONTAINER_NAME\" || echo 'Failed to stop container or container not running'" >>"$JOB_CLEANUP_SCRIPT"
-    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v $OUT_DIR:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" bash
-    docker exec -i $CONTAINER_NAME bash -c "source /opt/rh/gcc-toolset-13/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
+    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v /data/builds:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash
+    docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
     docker stop $CONTAINER_NAME
   fi
 fi

src/test/rpc/ServerDefinitions_test.cpp

@@ -163,7 +163,7 @@ public:
     void
     testNoParams(FeatureBitset features)
     {
-        testcase("Default Env: config-forced, none on-ledger");
+        testcase("No Params, None Enabled");
 
         using namespace test::jtx;
         Env env{*this};
@@ -178,6 +178,8 @@ public:
         {
             if (!BEAST_EXPECT(feature.isMember(jss::name)))
                 return;
+            // default config - so all should be disabled, and
+            // supported. Some may be vetoed.
             bool expectVeto =
                 (votes.at(feature[jss::name].asString()) ==
                  VoteBehavior::DefaultNo);
@@ -186,12 +188,8 @@ public:
                  VoteBehavior::Obsolete);
             BEAST_EXPECTS(
                 feature.isMember(jss::enabled) &&
-                    feature[jss::enabled].asBool(),
+                    !feature[jss::enabled].asBool(),
                 feature[jss::name].asString() + " enabled");
-            BEAST_EXPECTS(
-                feature.isMember(jss::ledger_enabled) &&
-                    !feature[jss::ledger_enabled].asBool(),
-                feature[jss::name].asString() + " ledger_enabled");
             BEAST_EXPECTS(
                 feature.isMember(jss::vetoed) &&
                     feature[jss::vetoed].isBool() == !expectObsolete &&
@@ -210,7 +208,7 @@ public:
     void
     testSomeEnabled(FeatureBitset features)
     {
-        testcase("Two config-forced, none on-ledger");
+        testcase("No Params, Some Enabled");
 
         using namespace test::jtx;
         Env env{
@@ -230,10 +228,7 @@ public:
             (void)id.parseHex(it.key().asString().c_str());
             if (!BEAST_EXPECT((*it).isMember(jss::name)))
                 return;
-            bool const expectOnLedger =
-                env.app().getAmendmentTable().isEnabled(id);
-            bool const expectForced =
-                id == featureDepositAuth || id == featureDepositPreauth;
+            bool expectEnabled = env.app().getAmendmentTable().isEnabled(id);
             bool expectSupported =
                 env.app().getAmendmentTable().isSupported(id);
             bool expectVeto =
@@ -244,14 +239,9 @@ public:
                  VoteBehavior::Obsolete);
             BEAST_EXPECTS(
                 (*it).isMember(jss::enabled) &&
-                    (*it)[jss::enabled].asBool() ==
-                        (expectOnLedger || expectForced),
+                    (*it)[jss::enabled].asBool() == expectEnabled,
                 (*it)[jss::name].asString() + " enabled");
-            BEAST_EXPECTS(
-                (*it).isMember(jss::ledger_enabled) &&
-                    (*it)[jss::ledger_enabled].asBool() == expectOnLedger,
-                (*it)[jss::name].asString() + " ledger_enabled");
-            if (expectOnLedger)
+            if (expectEnabled)
                 BEAST_EXPECTS(
                     !(*it).isMember(jss::vetoed),
                     (*it)[jss::name].asString() + " vetoed");
@@ -370,122 +360,12 @@ public:
         }
     }
 
-    void
-    testConfigForced(FeatureBitset features)
-    {
-        testcase("Config-forced features ([features] stanza)");
-
-        using namespace test::jtx;
-
-        auto const forced = featurePriceOracle;
-        auto const forcedHex = to_string(forced);
-
-        Env env{*this, FeatureBitset(forced)};
-
-        auto jrr = env.rpc("server_definitions")[jss::result];
-        if (!BEAST_EXPECT(jrr.isMember(jss::features)))
-            return;
-
-        bool sawForced = false;
-        for (auto it = jrr[jss::features].begin();
-             it != jrr[jss::features].end();
-             ++it)
-        {
-            auto const& f = *it;
-            auto const name = f[jss::name].asString();
-
-            if (!BEAST_EXPECTS(
-                    f.isMember(jss::enabled) && f.isMember(jss::ledger_enabled),
-                    name + " enabled/ledger_enabled"))
-                return;
-
-            BEAST_EXPECTS(
-                !f[jss::ledger_enabled].asBool(), name + " ledger_enabled");
-
-            if (it.key().asString() == forcedHex)
-            {
-                sawForced = true;
-                BEAST_EXPECTS(f[jss::enabled].asBool(), name + " enabled");
-            }
-            else
-            {
-                BEAST_EXPECTS(!f[jss::enabled].asBool(), name + " enabled");
-            }
-        }
-        BEAST_EXPECT(sawForced);
-    }
-
-    void
-    testOnLedger(FeatureBitset features)
-    {
-        testcase("On-ledger plus one config-forced");
-
-        using namespace test::jtx;
-
-        // Veto XahauGenesis: FRESH would otherwise enable it via pseudo-tx.
-        auto const forced = featurePriceOracle;
-        auto const forcedHex = to_string(forced);
-
-        Env env{
-            *this,
-            envconfig([](std::unique_ptr<Config> cfg) {
-                cfg->START_UP = Config::FRESH;
-                cfg->section(SECTION_VETO_AMENDMENTS)
-                    .append(to_string(featureXahauGenesis) + " XahauGenesis");
-                return cfg;
-            }),
-            FeatureBitset(forced)};
-
-        auto jrr = env.rpc("server_definitions")[jss::result];
-        if (!BEAST_EXPECT(jrr.isMember(jss::features)))
-            return;
-
-        bool sawOnLedger = false;
-        bool sawForced = false;
-        for (auto it = jrr[jss::features].begin();
-             it != jrr[jss::features].end();
-             ++it)
-        {
-            uint256 id;
-            (void)id.parseHex(it.key().asString().c_str());
-            auto const& f = *it;
-            auto const name = f[jss::name].asString();
-
-            if (!BEAST_EXPECTS(
-                    f.isMember(jss::enabled) && f.isMember(jss::ledger_enabled),
-                    name + " enabled/ledger_enabled"))
-                return;
-
-            bool const onLedger = env.app().getAmendmentTable().isEnabled(id);
-            bool const isForced = it.key().asString() == forcedHex;
-
-            BEAST_EXPECTS(
-                f[jss::ledger_enabled].asBool() == onLedger,
-                name + " ledger_enabled");
-            BEAST_EXPECTS(
-                f[jss::enabled].asBool() == (onLedger || isForced),
-                name + " enabled");
-
-            if (onLedger)
-                sawOnLedger = true;
-            if (isForced)
-            {
-                sawForced = true;
-                BEAST_EXPECTS(!onLedger, name + " forced not on-ledger");
-            }
-        }
-        BEAST_EXPECT(sawOnLedger);
-        BEAST_EXPECT(sawForced);
-    }
-
     void
     testServerFeatures(FeatureBitset features)
     {
         testNoParams(features);
         testSomeEnabled(features);
         testWithMajorities(features);
-        testConfigForced(features);
-        testOnLedger(features);
     }
 
     void

src/xrpld/app/tx/detail/ClaimReward.cpp

@@ -30,6 +30,12 @@
 
 namespace ripple {
 
+TxConsequences
+ClaimReward::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, TxConsequences::normal};
+}
+
 NotTEC
 ClaimReward::preflight(PreflightContext const& ctx)
 {

src/xrpld/app/tx/detail/ClaimReward.h

@@ -32,12 +32,15 @@ namespace ripple {
 class ClaimReward : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
 
     explicit ClaimReward(ApplyContext& ctx) : Transactor(ctx)
     {
     }
 
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

src/xrpld/app/tx/detail/Cron.cpp

@@ -30,6 +30,12 @@
 
 namespace ripple {
 
+TxConsequences
+Cron::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, TxConsequences::normal};
+}
+
 NotTEC
 Cron::preflight(PreflightContext const& ctx)
 {

src/xrpld/app/tx/detail/Cron.h

@@ -30,7 +30,7 @@ namespace ripple {
 class Cron : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
 
     explicit Cron(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -39,6 +39,9 @@ public:
     static XRPAmount
     calculateBaseFee(ReadView const& view, STTx const& tx);
 
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

src/xrpld/app/tx/detail/CronSet.cpp

@@ -27,6 +27,12 @@
 
 namespace ripple {
 
+TxConsequences
+CronSet::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, TxConsequences::normal};
+}
+
 NotTEC
 CronSet::preflight(PreflightContext const& ctx)
 {

src/xrpld/app/tx/detail/CronSet.h

@@ -29,7 +29,7 @@ namespace ripple {
 class CronSet : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
 
     explicit CronSet(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -38,6 +38,9 @@ public:
     static XRPAmount
     calculateBaseFee(ReadView const& view, STTx const& tx);
 
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

src/xrpld/app/tx/detail/Invoke.cpp

@@ -26,6 +26,12 @@
 
 namespace ripple {
 
+TxConsequences
+Invoke::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, TxConsequences::normal};
+}
+
 NotTEC
 Invoke::preflight(PreflightContext const& ctx)
 {

src/xrpld/app/tx/detail/Invoke.h

@@ -30,7 +30,7 @@ namespace ripple {
 class Invoke : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
 
     explicit Invoke(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -39,6 +39,9 @@ public:
     static XRPAmount
     calculateBaseFee(ReadView const& view, STTx const& tx);
 
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

src/xrpld/app/tx/detail/SetRemarks.cpp

@@ -30,6 +30,12 @@
 
 namespace ripple {
 
+TxConsequences
+SetRemarks::makeTxConsequences(PreflightContext const& ctx)
+{
+    return TxConsequences{ctx.tx, TxConsequences::normal};
+}
+
 NotTEC
 SetRemarks::validateRemarks(STArray const& remarks, beast::Journal const& j)
 {

src/xrpld/app/tx/detail/SetRemarks.h

@@ -30,7 +30,7 @@ namespace ripple {
 class SetRemarks : public Transactor
 {
 public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
+    static constexpr ConsequencesFactoryType ConsequencesFactory{Custom};
 
     explicit SetRemarks(ApplyContext& ctx) : Transactor(ctx)
     {
@@ -39,6 +39,9 @@ public:
     static XRPAmount
     calculateBaseFee(ReadView const& view, STTx const& tx);
 
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

src/xrpld/rpc/handlers/ServerDefinitions.cpp

@@ -22,7 +22,6 @@
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/misc/AmendmentTable.h>
 #include <xrpld/app/misc/NetworkOPs.h>
-#include <xrpld/core/Config.h>
 #include <xrpld/rpc/detail/TransactionSign.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/json_writer.h>
@@ -546,25 +545,6 @@ doServerDefinitions(RPC::JsonContext& context)
             features[to_string(h)][jss::majority] =
                 t.time_since_epoch().count();
 
-        // getJson's enabled is on-ledger; [features] also apply here.
-        for (auto const& name : features.getMemberNames())
-        {
-            Json::Value& entry = features[name];
-            entry[jss::ledger_enabled] = entry[jss::enabled].asBool();
-        }
-        for (auto const& h : context.app.config().features)
-        {
-            Json::Value& entry = features[to_string(h)];
-            if (!entry.isMember(jss::name))
-            {
-                if (auto const fname = featureToName(h); !fname.empty())
-                    entry[jss::name] = fname;
-            }
-            if (!entry.isMember(jss::ledger_enabled))
-                entry[jss::ledger_enabled] = false;
-            entry[jss::enabled] = true;
-        }
-
         lastFeatures = features;
         {
             const std::string out = Json::FastWriter().write(features);