Merge branch 'dev' into coverage

This reverts commit 5c1d7d9ae9.

.codecov.yml

@@ -1,46 +1,6 @@
-codecov:
-  require_ci_to_pass: true
-
-comment:
-  behavior: default
-  layout: reach,diff,flags,tree,reach
-  show_carryforward_flags: false
-
 coverage:
-  range: "60..80"
-  precision: 1
-  round: nearest
   status:
     project:
       default:
         target: 60%
         threshold: 2%
-    patch:
-      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:
-  annotations: true
-
-parsers:
-  cobertura:
-    partials_as_hits: true
-    handle_missing_conditions : true
-
-slack_app: false
-
-ignore:
-  - "src/test/"
-  - "include/xrpl/beast/test/"
-  - "include/xrpl/beast/unit_test/"

.git-blame-ignore-revs

@@ -1,25 +1,8 @@
 # This feature requires Git >= 2.24
 # To use it by default in git blame:
 # git config blame.ignoreRevsFile .git-blame-ignore-revs
-# Format first-party source according to .clang-format
 50760c693510894ca368e90369b0cc2dabfd07f3
-# Reintroduce Clang-Format & Levelization
-da1d20d6d5d862716125d60899b80fab5302954a
-# Consolidate external libraries
-da1d20d6d5d862716125d60899b80fab5302954a
-# Rename .hpp to .h
-0345a2645d0f5ad900f4fbbcaff96040d3a887fc
-# Format formerly .hpp files
-5a227dc719016e10045e17c9396ad401118044f1
-# Rewrite includes
-e61880699997398f5a746e6c4034edc7632661f5
-# Move CMake directory (#4997)
-e47b1c1b3b97c3f6d11858ee02f463596e29e7f0
-# Rearrange sources (#4997)
-bfafa2bb39e562901736d656806bd700c3699a2f
-# Rewrite includes (#4997)
-e61880699997398f5a746e6c4034edc7632661f5
-# Recompute loops (#4997)
-d25b5dcd568bb96c18e347d55fac10fe901a1bfb
-# Reformat code with clang-format-18
-02749feea88ce61c1f7eeb2d61a57d8ecf07ab11
+e2384885f5f630c8f0ffe4bf21a169b433a16858
+241b9ddde9e11beb7480600fd5ed90e1ef109b21
+760f16f56835663d9286bd29294d074de26a7ba6
+0eebe6a5f4246fced516d52b83ec4e7f47373edd

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

@@ -50,10 +50,6 @@ 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:
@@ -85,8 +81,6 @@ 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
@@ -111,14 +105,7 @@ runs:
         os=${{ inputs.os }}
         EOF
 
-        # [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
+        # Add buildenv and conf sections for Linux (not needed for macOS)
         if [ "${{ inputs.os }}" = "Linux" ] && [ -n "${{ inputs.cc }}" ]; then
           cat >> ~/.conan2/profiles/default <<EOF
 
@@ -129,38 +116,16 @@ runs:
         [conf]
         tools.build:compiler_executables={"c": "/usr/bin/${{ inputs.cc }}", "cpp": "/usr/bin/${{ inputs.cxx }}"}
         EOF
-          NEED_CONF=1
         fi
 
-        if [ -n "${CONAN_DEPS_CXXFLAGS}" ] && [ "${CONAN_DEPS_CXXFLAGS}" != "{}" ]; then
-          CONAN_DEPS_CXXFLAGS_LINES="$(python3 - <<'PY'
-        import json
-        import os
-        import sys
+        # Add macOS-specific conf if needed
+        if [ "${{ inputs.os }}" = "Macos" ]; then
+          cat >> ~/.conan2/profiles/default <<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
+        [conf]
+        # Workaround for gRPC with newer Apple Clang
+        tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
+        EOF
         fi
 
         # Display profile for verification

.github/workflows/build-in-docker.yml

@@ -15,9 +15,6 @@ env:
 
 jobs:
   checkout:
-    # build publishes to build.xahau.tech, so this workflow only runs from
-    # Xahau/xahaud. build and tests are skipped along with this job.
-    if: github.repository == 'Xahau/xahaud'
     runs-on: [self-hosted, vanity]
     outputs:
       checkout_path: ${{ steps.vars.outputs.checkout_path }}
@@ -89,16 +86,10 @@ jobs:
   cleanup:
     runs-on: [self-hosted, xahaud-build]
     needs: [tests, checkout]
-    if: always() && github.repository == 'Xahau/xahaud'
+    if: always()
     steps:
       - name: Cleanup workspace
         run: |
           CHECKOUT_PATH="${{ needs.checkout.outputs.checkout_path }}"
-          # A run cancelled before checkout has no path; an empty one would
-          # make the rm below delete every run's checkout on the runner.
-          if [[ -z "${CHECKOUT_PATH}" ]]; then
-            echo "No checkout path (cancelled before checkout); nothing to clean"
-            exit 0
-          fi
           echo "Cleaning workspace for ${CHECKOUT_PATH}"
           rm -rf "${{ github.workspace }}/${CHECKOUT_PATH}"

.github/workflows/clang-format.yml

@@ -20,7 +20,7 @@ jobs:
         sudo apt-get update
         sudo apt-get install clang-format-${CLANG_VERSION}
     - name: Format first-party sources
-      run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
+      run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -not -path "src/magic/magic_enum.h" -exec clang-format-${CLANG_VERSION} -i {} +
     - name: Check for differences
       id: assert
       run: |

.github/workflows/verify-generated-headers.yml

@@ -18,10 +18,6 @@ jobs:
             generator: bash ./hook/generate_sfcodes.sh
           - target: hook/tts.h
             generator: ./hook/generate_tts.sh
-          - target: hook/ls_flags.h
-            generator: ./hook/generate_lsflags.sh
-          - target: hook/tx_flags.h
-            generator: ./hook/generate_txflags.sh
     runs-on: ubuntu-24.04
     env:
       CLANG_VERSION: 18

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

@@ -107,9 +107,6 @@ 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

@@ -8,6 +8,12 @@ on:
     types: [opened, synchronize, reopened, labeled, unlabeled]
   schedule:
     - cron: '0 0 * * *'
+  workflow_dispatch:
+    inputs:
+      full_matrix:
+        description: "Force full matrix (6 configs)"
+        required: false
+        default: "false"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -24,14 +30,37 @@ jobs:
     outputs:
       matrix: ${{ steps.set-matrix.outputs.matrix }}
     steps:
+      - name: escape double quotes
+        id: escape
+        shell: bash
+        env:
+          PR_TITLE: ${{ github.event.pull_request.title }}
+        run: |
+          ESCAPED_PR_TITLE="${PR_TITLE//\"/\\\"}"
+          echo "title=${ESCAPED_PR_TITLE}" >> "$GITHUB_OUTPUT"
       - name: Generate build matrix
         id: set-matrix
         shell: python
+        env:
+          GH_TOKEN: ${{ github.token }}
         run: |
           import json
           import os
+          import urllib.request
 
-          matrix = [
+          # Full matrix with all 6 compiler configurations
+          # Each configuration includes all parameters needed by the build job
+          full_matrix = [
+              {
+                  "compiler_id": "gcc-11-libstdcxx",
+                  "compiler": "gcc",
+                  "cc": "gcc-11",
+                  "cxx": "g++-11",
+                  "compiler_version": 11,
+                  "stdlib": "default",
+                  "configuration": "Debug",
+                  "job_type": "build"
+              },
               {
                   "compiler_id": "gcc-13-libstdcxx",
                   "compiler": "gcc",
@@ -43,26 +72,26 @@ jobs:
                   "job_type": "build"
               },
               {
-                  # 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",
+                  "compiler_id": "gcc-13-libstdcxx",
+                  "compiler": "gcc",
+                  "cc": "gcc-13",
+                  "cxx": "g++-13",
+                  "gcov": "gcov-13",
+                  "compiler_version": 13,
+                  "stdlib": "default",
                   "configuration": "Debug",
-                  "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"]
-                  }
+                  "job_type": "coverage"
+              },
+              {
+                  "compiler_id": "clang-14-libstdcxx-gcc11",
+                  "compiler": "clang",
+                  "cc": "clang-14",
+                  "cxx": "clang++-14",
+                  "compiler_version": 14,
+                  "stdlib": "libstdcxx",
+                  "clang_gcc_toolchain": 11,
+                  "configuration": "Debug",
+                  "job_type": "build"
               },
               {
                   "compiler_id": "clang-16-libstdcxx-gcc13",
@@ -74,8 +103,117 @@ jobs:
                   "clang_gcc_toolchain": 13,
                   "configuration": "Debug",
                   "job_type": "build"
+              },
+              {
+                  "compiler_id": "clang-17-libcxx",
+                  "compiler": "clang",
+                  "cc": "clang-17",
+                  "cxx": "clang++-17",
+                  "compiler_version": 17,
+                  "stdlib": "libcxx",
+                  "configuration": "Debug",
+                  "job_type": "build"
+              },
+              {
+                  # Clang 18 - testing if it's faster than Clang 17 with libc++
+                  # Requires patching Conan v1 settings.yml to add version 18
+                  "compiler_id": "clang-18-libcxx",
+                  "compiler": "clang",
+                  "cc": "clang-18",
+                  "cxx": "clang++-18",
+                  "compiler_version": 18,
+                  "stdlib": "libcxx",
+                  "configuration": "Debug",
+                  "job_type": "build"
               }
           ]
+          
+          # 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[3]   # clang-14 (mature, stable clang)
+          ]
+          
+          # Determine which matrix to use based on the target branch
+          ref = "${{ github.ref }}"
+          base_ref = "${{ github.base_ref }}"  # For PRs, this is the target branch
+          event_name = "${{ github.event_name }}"
+          pr_title = """${{ steps.escape.outputs.title }}"""
+          pr_labels = """${{ join(github.event.pull_request.labels.*.name, ',') }}"""
+          pr_head_sha = "${{ github.event.pull_request.head.sha }}"
+
+          # Get commit message - for PRs, fetch via API since head_commit.message is empty
+          if event_name == "pull_request" and pr_head_sha:
+              try:
+                  url = f"https://api.github.com/repos/${{ github.repository }}/commits/{pr_head_sha}"
+                  req = urllib.request.Request(url, headers={
+                      "Accept": "application/vnd.github.v3+json",
+                      "Authorization": f"Bearer {os.environ.get('GH_TOKEN', '')}"
+                  })
+                  with urllib.request.urlopen(req) as response:
+                      data = json.load(response)
+                      commit_message = data["commit"]["message"]
+              except Exception as e:
+                  print(f"Failed to fetch commit message: {e}")
+                  commit_message = ""
+          else:
+              commit_message = """${{ github.event.head_commit.message }}"""
+
+          # Debug logging
+          print(f"Event: {event_name}")
+          print(f"Ref: {ref}")
+          print(f"Base ref: {base_ref}")
+          print(f"PR head SHA: {pr_head_sha}")
+          print(f"PR title: {pr_title}")
+          print(f"PR labels: {pr_labels}")
+          print(f"Commit message: {commit_message}")
+          
+          # Manual trigger input to force full matrix.
+          manual_full = "${{ github.event.inputs.full_matrix || 'false' }}" == "true"
+
+          # Label/manual overrides, while preserving existing title/commit behavior.
+          force_full = (
+              manual_full
+              or "[ci-nix-full-matrix]" in commit_message
+              or "[ci-nix-full-matrix]" in pr_title
+              or ("ci-full-build" in pr_labels and "ci-nix-full-matrix" in pr_labels)
+          )
+          force_min = (
+              "ci-full-build" in pr_labels
+          )
+          print(f"Force full matrix: {force_full}")
+          print(f"Force min matrix: {force_min}")
+          
+          # Check if this is targeting a main branch
+          # For PRs: check base_ref (target branch)
+          # For pushes: check ref (current branch)
+          main_branches = ["refs/heads/dev", "refs/heads/release", "refs/heads/candidate"]
+          
+          if force_full:
+              # Override: always use full matrix if forced by manual input or label.
+              use_full = True
+          elif force_min:
+              # Override: always use minimal matrix if ci-full-build label is present.
+              use_full = False
+          elif event_name == "pull_request":
+              # For PRs, base_ref is just the branch name (e.g., "dev", not "refs/heads/dev")
+              # Check if the PR targets release or candidate (more critical branches)
+              use_full = base_ref in ["release", "candidate"]
+          else:
+              # For pushes, ref is the full reference (e.g., "refs/heads/dev")
+              use_full = ref in main_branches
+          
+          # Select the appropriate matrix
+          if use_full:
+              if force_full:
+                  print(f"Using FULL matrix (7 configs) - forced by [ci-nix-full-matrix] tag")
+              else:
+                  print(f"Using FULL matrix (7 configs) - targeting main branch")
+              matrix = full_matrix
+          else:
+              print(f"Using MINIMAL matrix (3 configs) - feature branch/PR")
+              matrix = minimal_matrix
 
           # Add runs_on based on job_type
           for entry in matrix:
@@ -92,9 +230,6 @@ jobs:
   build:
     needs: matrix-setup
     runs-on: ${{ fromJSON(matrix.runs_on) }}
-    permissions:
-      id-token: write
-      contents: read
     container:
       image: ubuntu:24.04
       volumes:
@@ -119,25 +254,9 @@ 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
@@ -210,16 +329,10 @@ jobs:
           pipx install "conan>=2.0,<3"
           echo "$HOME/.local/bin" >> $GITHUB_PATH
 
-          # Install coverage tooling
+          # Install gcovr for coverage jobs
           if [ "${{ matrix.job_type }}" = "coverage" ]; then
-            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
+            pipx install "gcovr>=7,<9"
+            apt-get install -y lcov
           fi
 
       - name: Check environment
@@ -232,15 +345,10 @@ jobs:
           which ${{ matrix.cxx }} && ${{ matrix.cxx }} --version || echo "${{ matrix.cxx }} not found"
           which ccache && ccache --version || echo "ccache not found"
 
-          # Check coverage tooling
+          # Check gcovr for coverage jobs
           if [ "${{ matrix.job_type }}" = "coverage" ]; then
-            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
+            which gcov && gcov --version || echo "gcov not found"
+            which gcovr && gcovr --version || echo "gcovr not found"
           fi
 
           echo "---- Full Environment ----"
@@ -267,7 +375,6 @@ 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
@@ -300,9 +407,7 @@ 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.
-          # 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-args: '-Dcoverage=ON -Dcoverage_format=xml -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_CXX_FLAGS="-O0" -DCMAKE_C_FLAGS="-O0"'
           cmake-target: 'coverage'
           ccache_max_size: '100G'
 
@@ -334,41 +439,28 @@ 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_FILE}" ./
-          echo "COVERAGE_FILE=${COVERAGE_FILE}" >> "$GITHUB_ENV"
+          mv "${{ env.build_dir }}/coverage.xml" ./
 
       - name: Archive coverage report
         if: matrix.job_type == 'coverage'
         uses: actions/upload-artifact@v4
         with:
-          name: ${{ env.COVERAGE_FILE }}-${{ matrix.compiler_id }}
-          path: ${{ env.COVERAGE_FILE }}
+          name: coverage.xml
+          path: coverage.xml
           retention-days: 30
 
       - name: Upload coverage report
-        if: matrix.job_type == 'coverage' && github.repository == 'Xahau/xahaud'
-        uses: codecov/codecov-action@v5
+        if: matrix.job_type == 'coverage'
+        uses: wandalen/wretry.action/main@v3
         with:
-          files: ${{ env.COVERAGE_FILE }}
-          flags: ${{ matrix.coverage_tool }}
-          fail_ci_if_error: true
-          disable_search: true
-          verbose: true
-          plugins: noop
-          use_oidc: true
-
-      - name: Export server definitions
-        if: matrix.job_type == 'build' && matrix.compiler_id == 'gcc-13-libstdcxx'
-        run: |
-          ${{ env.build_dir }}/rippled --definitions | python3 -m json.tool > server_definitions.json
-
-      - name: Upload server definitions
-        if: matrix.job_type == 'build' && matrix.compiler_id == 'gcc-13-libstdcxx'
-        uses: actions/upload-artifact@v7
-        with:
-          name: server-definitions
-          path: server_definitions.json
-          archive: false
+          action: codecov/[email protected]
+          with: |
+            files: coverage.xml
+            fail_ci_if_error: true
+            disable_search: true
+            verbose: true
+            plugin: noop
+            token: ${{ secrets.CODECOV_TOKEN }}
+          attempt_limit: 5
+          attempt_delay: 210000 # in milliseconds

Builds/levelization/results/ordering.txt

@@ -32,7 +32,6 @@ test.basics > xrpld.perflog
 test.basics > xrpld.rpc
 test.basics > xrpl.json
 test.basics > xrpl.protocol
-test.beast > test.unit_test
 test.beast > xrpl.basics
 test.conditions > xrpl.basics
 test.conditions > xrpld.conditions
@@ -78,11 +77,6 @@ test.ledger > xrpld.app
 test.ledger > xrpld.core
 test.ledger > xrpld.ledger
 test.ledger > xrpl.protocol
-test.net > test.toplevel
-test.net > xrpl.basics
-test.net > xrpld.core
-test.net > xrpld.net
-test.net > xrpl.json
 test.nodestore > test.jtx
 test.nodestore > test.toplevel
 test.nodestore > test.unit_test
@@ -90,13 +84,11 @@ test.nodestore > xrpl.basics
 test.nodestore > xrpld.core
 test.nodestore > xrpld.nodestore
 test.nodestore > xrpld.unity
-test.nodestore > xrpl.protocol
 test.overlay > test.jtx
 test.overlay > test.toplevel
 test.overlay > test.unit_test
 test.overlay > xrpl.basics
 test.overlay > xrpld.app
-test.overlay > xrpld.core
 test.overlay > xrpld.overlay
 test.overlay > xrpld.peerfinder
 test.overlay > xrpld.shamap
@@ -126,7 +118,6 @@ test.rpc > xrpld.core
 test.rpc > xrpld.net
 test.rpc > xrpld.overlay
 test.rpc > xrpld.rpc
-test.rpc > xrpld.shamap
 test.rpc > xrpl.hook
 test.rpc > xrpl.json
 test.rpc > xrpl.protocol
@@ -192,7 +183,6 @@ xrpld.overlay > xrpl.basics
 xrpld.overlay > xrpld.core
 xrpld.overlay > xrpld.peerfinder
 xrpld.overlay > xrpld.perflog
-xrpld.overlay > xrpld.shamap
 xrpld.overlay > xrpl.json
 xrpld.overlay > xrpl.protocol
 xrpld.overlay > xrpl.resource
@@ -208,7 +198,6 @@ xrpld.rpc > xrpld.core
 xrpld.rpc > xrpld.ledger
 xrpld.rpc > xrpld.nodestore
 xrpld.rpc > xrpld.shamap
-xrpld.rpc > xrpl.hook
 xrpld.rpc > xrpl.json
 xrpld.rpc > xrpl.protocol
 xrpld.rpc > xrpl.resource

CMakeLists.txt

@@ -122,7 +122,6 @@ endif()
 find_package(nudb REQUIRED)
 find_package(date REQUIRED)
 find_package(xxHash REQUIRED)
-find_package(magic_enum REQUIRED)
 
 include(deps/WasmEdge) 
   if(TARGET nudb::core)

build-core.sh

@@ -95,16 +95,8 @@ if [[ "$4" == "" ]]; then
   echo "Non GH, local building, no Action runner magic"
 else
   # GH Action, runner
-    if [[ "$(git rev-parse --abbrev-ref HEAD)" == "release" ]]; then
-        echo "building on the release branch... placing it in builds/candidate"
-        mkdir /data/builds/candidate
-        cp /io/release-build/xahaud /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
-        cp /io/release-build/release.info /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
-    else
-        echo "building non-release branch, placing it in builds root"
-        cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
-        cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
-    fi  
+  cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+  cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
   echo "Published build to: http://build.xahau.tech/"
   echo $(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
 fi

build-full.sh

@@ -12,16 +12,17 @@ echo "-- GITHUB_REPOSITORY: $1"
 echo "-- GITHUB_SHA:        $2"
 echo "-- GITHUB_RUN_NUMBER: $4"
 
-umask 0000
+umask 0000;
 
 ####
 
-cd /io
-mkdir -p src/certs
-curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h
-if [ "$(grep certbundle.h src/xrpld/net/detail/RegisterSSLCerts.cpp | wc -l)" -eq "0" ]; then
-  cp src/xrpld/net/detail/RegisterSSLCerts.cpp src/xrpld/net/detail/RegisterSSLCerts.cpp.old
-  perl -i -pe "s/^{/{
+cd /io;
+mkdir -p src/certs;
+curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h;
+if [ "`grep certbundle.h src/xrpld/net/detail/RegisterSSLCerts.cpp | wc -l`" -eq "0" ]
+then
+    cp src/xrpld/net/detail/RegisterSSLCerts.cpp src/xrpld/net/detail/RegisterSSLCerts.cpp.old
+    perl -i -pe "s/^{/{
     #ifdef EMBEDDED_CA_BUNDLE
     BIO *cbio = BIO_new_mem_buf(ca_bundle.data(), ca_bundle.size());
     X509_STORE  *cts = SSL_CTX_get_cert_store(ctx.native_handle());
@@ -67,14 +68,15 @@ fi
 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++' &&
-  echo "-- Build Rippled --" &&
-  pwd &&
-  echo "MOVING TO [ build-core.sh ]"
+export CXX='/usr/lib64/ccache/g++' &&
+echo "-- Build Rippled --" &&
+pwd &&
 
-printenv >.env.temp
-cat .env.temp | grep '=' | sed s/\\\(^[^=]\\+=\\\)/\\1\\\"/g | sed s/\$/\\\"/g >.env
-rm .env.temp
+echo "MOVING TO [ build-core.sh ]";
+
+printenv > .env.temp;
+cat .env.temp | grep '=' | sed s/\\\(^[^=]\\+=\\\)/\\1\\\"/g|sed s/\$/\\\"/g > .env;
+rm .env.temp;
 
 echo "Persisting ENV:"
 cat .env

cfg/xahaud-example.cfg

@@ -494,7 +494,7 @@
 #
 #   Configure the maximum number of transactions to have in the job queue
 #
-#   Must be a number between 100 and 1000, defaults to 1000
+#   Must be a number between 100 and 1000, defaults to 250
 #
 #
 # [overlay]
@@ -593,7 +593,7 @@
 #       reaches or exceeds this number. After that the limit may still
 #       change, but will stay above the target. If consensus is not
 #       healthy, the limit will be clamped to this value or lower.
-#       Default: 1000.
+#       Default: 50.
 #
 #   maximum_txn_in_ledger = <number>
 #

cfg/xahaud-standalone.cfg

@@ -146,6 +146,8 @@ D686F2538F410C9D0D856788E98E3579595DAF7B38D38887F81ECAC934B06040 HooksUpdate1
 3C43D9A973AA4443EF3FC38E42DD306160FBFFDAB901CD8BAA15D09F2597EB87 NonFungibleTokensV1
 0285B7E5E08E1A8E4C15636F0591D87F73CB6A7B6452A932AD72BBC8E5D1CBE3 fixNFTokenDirV1
 36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6 fixNFTokenNegOffer
+4C499D17719BB365B69010A436B64FD1A82AAB199FC1CEB06962EBD01059FB09 fixXahauV1
+215181D23BF5C173314B5FDB9C872C92DE6CC918483727DE037C0C13E7E6EE9D fixXahauV2
 0D8BF22FF7570D58598D1EF19EBB6E142AD46E59A223FD3816262FBB69345BEA Remit
 7CA0426E7F411D39BB014E57CD9E08F61DE1750F0D41FCD428D9FB80BB7596B0 ZeroB2M
 4B8466415FAB32FFA89D9DCBE166A42340115771DF611A7160F8D7439C87ECD8 fixNSDelete

cmake/CodeCoverage.cmake

@@ -95,9 +95,6 @@
 #     - replace both functions setup_target_for_coverage_gcovr_* with a single setup_target_for_coverage_gcovr
 #     - add support for all gcovr output formats
 #
-# 2024-04-03, Bronek Kozicki
-#     - add support for output formats: jacoco, clover, lcov
-#
 # USAGE:
 #
 # 1. Copy this file into your cmake modules path.
@@ -259,10 +256,10 @@ endif()
 #     BASE_DIRECTORY "../"                   # Base directory for report
 #                                            #  (defaults to PROJECT_SOURCE_DIR)
 #     FORMAT "cobertura"                     # Output format, one of:
-#                                            #  xml cobertura sonarqube jacoco clover
-#                                            #  json-summary json-details coveralls csv
-#                                            #  txt html-single html-nested html-details
-#                                            #  lcov (xml is an alias to cobertura;
+#                                            #  xml cobertura sonarqube json-summary
+#                                            #  json-details coveralls csv txt
+#                                            #  html-single html-nested html-details
+#                                            #  (xml is an alias to cobertura;
 #                                            #  if no format is set, defaults to xml)
 #     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
 #                                            #  to BASE_DIRECTORY, with CMake 3.4+)
@@ -311,8 +308,6 @@ function(setup_target_for_coverage_gcovr)
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
         elseif(Coverage_FORMAT STREQUAL "csv")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
-        elseif(Coverage_FORMAT STREQUAL "lcov")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
         else()
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
         endif()
@@ -325,14 +320,6 @@ function(setup_target_for_coverage_gcovr)
         set(Coverage_FORMAT cobertura) # overwrite xml
     elseif(Coverage_FORMAT STREQUAL "sonarqube")
         list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}" )
-    elseif(Coverage_FORMAT STREQUAL "jacoco")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}" )
-        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty )
-    elseif(Coverage_FORMAT STREQUAL "clover")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}" )
-        list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty )
-    elseif(Coverage_FORMAT STREQUAL "lcov")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}" )
     elseif(Coverage_FORMAT STREQUAL "json-summary")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}" )
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)
@@ -393,7 +380,6 @@ function(setup_target_for_coverage_gcovr)
         ${GCOVR_PATH}
         --gcov-executable ${GCOV_TOOL}
         --gcov-ignore-parse-errors=negative_hits.warn_once_per_file
-        --gcov-ignore-parse-errors=suspicious_hits.warn_once_per_file
         -r ${BASEDIR}
         ${GCOVR_ADDITIONAL_ARGS}
         ${GCOVR_EXCLUDE_ARGS}

cmake/CodeCoverageLLVM.cmake

@@ -1,156 +0,0 @@
-#[===================================================================[
-  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/RippledCore.cmake

@@ -54,7 +54,6 @@ add_library(xrpl.imports.main INTERFACE)
 target_link_libraries(xrpl.imports.main
   INTERFACE
     LibArchive::LibArchive
-    magic_enum::magic_enum
     OpenSSL::Crypto
     Ripple::boost
     wasmedge::wasmedge

cmake/RippledCov.cmake

@@ -11,21 +11,6 @@ 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,17 +28,15 @@ 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}>,$<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>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<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>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 

cmake/RippledSettings.cmake

@@ -29,25 +29,13 @@ 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 (gcov tool only).")
+    "Additional arguments to pass to gcovr.")
   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)
@@ -124,7 +112,7 @@ option(beast_no_unit_test_inline
   "Prevents unit test definitions from being inserted into global table"
   OFF)
 option(single_io_service_thread
-  "Restricts the number of threads calling io_context::run to one. \
+  "Restricts the number of threads calling io_service::run to one. \
   This can be useful when debugging."
   OFF)
 option(boost_show_deprecated

cmake/deps/Boost.cmake

@@ -32,9 +32,9 @@ target_link_libraries(ripple_boost
     Boost::date_time
     Boost::filesystem
     Boost::json
-    Boost::process
     Boost::program_options
     Boost::regex
+    Boost::system
     Boost::iostreams
     Boost::thread)
 if(Boost_COMPILER)

conanfile.py

@@ -2,160 +2,157 @@ from conan import ConanFile
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 import re
 
-
 class Xrpl(ConanFile):
-    name = "xrpl"
+    name = 'xrpl'
 
-    license = "ISC"
-    author = "John Freeman <[email protected]>"
-    url = "https://github.com/xrplf/rippled"
-    description = "The XRP Ledger"
-    settings = "os", "compiler", "build_type", "arch"
+    license = 'ISC'
+    author = 'John Freeman <[email protected]>'
+    url = 'https://github.com/xrplf/rippled'
+    description = 'The XRP Ledger'
+    settings = 'os', 'compiler', 'build_type', 'arch'
     options = {
-        "assertions": [True, False],
-        "coverage": [True, False],
-        "fPIC": [True, False],
-        "jemalloc": [True, False],
-        "rocksdb": [True, False],
-        "shared": [True, False],
-        "static": [True, False],
-        "tests": [True, False],
-        "unity": [True, False],
-        "xrpld": [True, False],
-        "with_wasmedge": [True, False],
-        "tool_requires_b2": [True, False],
+        'assertions': [True, False],
+        'coverage': [True, False],
+        'fPIC': [True, False],
+        'jemalloc': [True, False],
+        'rocksdb': [True, False],
+        'shared': [True, False],
+        'static': [True, False],
+        'tests': [True, False],
+        'unity': [True, False],
+        'xrpld': [True, False],
+        'with_wasmedge': [True, False],
+        'tool_requires_b2': [True, False],
     }
 
     requires = [
-        "date/3.0.3",
-        "grpc/1.50.1",
-        "libarchive/3.7.6",
-        "magic_enum/0.9.5",
-        "nudb/2.0.9",
-        "openssl/3.6.0",
-        "soci/4.0.3@xahaud/stable",
-        "xxhash/0.8.2",
-        "zlib/1.3.1",
+        'date/3.0.3',
+        'grpc/1.50.1',
+        'libarchive/3.7.6',
+        'nudb/2.0.8',
+        'openssl/3.6.0',
+        'soci/4.0.3@xahaud/stable',
+        'xxhash/0.8.2',
+        'zlib/1.3.1',
     ]
 
     tool_requires = [
-        "protobuf/3.21.12",
+        'protobuf/3.21.12',
     ]
 
     default_options = {
-        "assertions": False,
-        "coverage": False,
-        "fPIC": True,
-        "jemalloc": False,
-        "rocksdb": True,
-        "shared": False,
-        "static": True,
-        "tests": False,
-        "unity": False,
-        "xrpld": False,
-        "with_wasmedge": True,
-        "tool_requires_b2": False,
-        "boost/*:without_cobalt": True,
-        "date/*:header_only": False,
-        "grpc/*:shared": False,
-        "grpc/*:secure": True,
-        "libarchive/*:shared": False,
-        "libarchive/*:with_acl": False,
-        "libarchive/*:with_bzip2": False,
-        "libarchive/*:with_cng": False,
-        "libarchive/*:with_expat": False,
-        "libarchive/*:with_iconv": False,
-        "libarchive/*:with_libxml2": False,
-        "libarchive/*:with_lz4": True,
-        "libarchive/*:with_lzma": False,
-        "libarchive/*:with_lzo": False,
-        "libarchive/*:with_nettle": False,
-        "libarchive/*:with_openssl": False,
-        "libarchive/*:with_pcreposix": False,
-        "libarchive/*:with_xattr": False,
-        "libarchive/*:with_zlib": False,
-        "lz4/*:shared": False,
-        "openssl/*:shared": False,
-        "protobuf/*:shared": False,
-        "protobuf/*:with_zlib": True,
-        "rocksdb/*:enable_sse": False,
-        "rocksdb/*:lite": False,
-        "rocksdb/*:shared": False,
-        "rocksdb/*:use_rtti": True,
-        "rocksdb/*:with_jemalloc": False,
-        "rocksdb/*:with_lz4": True,
-        "rocksdb/*:with_snappy": True,
-        "snappy/*:shared": False,
-        "soci/*:shared": False,
-        "soci/*:with_sqlite3": True,
-        "soci/*:with_boost": True,
-        "xxhash/*:shared": False,
+        'assertions': False,
+        'coverage': False,
+        'fPIC': True,
+        'jemalloc': False,
+        'rocksdb': True,
+        'shared': False,
+        'static': True,
+        'tests': False,
+        'unity': False,
+        'xrpld': False,
+        'with_wasmedge': True,
+        'tool_requires_b2': False,
+
+        'date/*:header_only': False,
+        'grpc/*:shared': False,
+        'grpc/*:secure': True,
+        'libarchive/*:shared': False,
+        'libarchive/*:with_acl': False,
+        'libarchive/*:with_bzip2': False,
+        'libarchive/*:with_cng': False,
+        'libarchive/*:with_expat': False,
+        'libarchive/*:with_iconv': False,
+        'libarchive/*:with_libxml2': False,
+        'libarchive/*:with_lz4': True,
+        'libarchive/*:with_lzma': False,
+        'libarchive/*:with_lzo': False,
+        'libarchive/*:with_nettle': False,
+        'libarchive/*:with_openssl': False,
+        'libarchive/*:with_pcreposix': False,
+        'libarchive/*:with_xattr': False,
+        'libarchive/*:with_zlib': False,
+        'lz4/*:shared': False,
+        'openssl/*:shared': False,
+        'protobuf/*:shared': False,
+        'protobuf/*:with_zlib': True,
+        'rocksdb/*:enable_sse': False,
+        'rocksdb/*:lite': False,
+        'rocksdb/*:shared': False,
+        'rocksdb/*:use_rtti': True,
+        'rocksdb/*:with_jemalloc': False,
+        'rocksdb/*:with_lz4': True,
+        'rocksdb/*:with_snappy': True,
+        'snappy/*:shared': False,
+        'soci/*:shared': False,
+        'soci/*:with_sqlite3': True,
+        'soci/*:with_boost': True,
+        'xxhash/*:shared': False,
     }
 
     def set_version(self):
-        path = f"{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp"
-        regex = r"versionString\s?=\s?\"(.*)\""
-        with open(path, "r") as file:
+        path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
+        regex = r'versionString\s?=\s?\"(.*)\"'
+        with open(path, 'r') as file:
             matches = (re.search(regex, line) for line in file)
             match = next(m for m in matches if m)
             self.version = match.group(1)
 
     def build_requirements(self):
         # These provide build tools (protoc, grpc plugins) that run during build
-        self.tool_requires("grpc/1.50.1")
+        self.tool_requires('grpc/1.50.1')
         # Explicitly require b2 (e.g. for building from source for glibc compatibility)
         if self.options.tool_requires_b2:
-            self.tool_requires("b2/5.3.2")
+            self.tool_requires('b2/5.3.2')
 
     def configure(self):
-        if self.settings.compiler == "apple-clang":
-            self.options["boost/*"].visibility = "global"
+        if self.settings.compiler == 'apple-clang':
+            self.options['boost/*'].visibility = 'global'
 
     def requirements(self):
         # Force sqlite3 version to avoid conflicts with soci
-        self.requires("sqlite3/3.47.0", override=True)
+        self.requires('sqlite3/3.47.0', override=True)
         # Force our custom snappy build for all dependencies
-        self.requires("snappy/1.1.10@xahaud/stable", override=True)
+        self.requires('snappy/1.1.10@xahaud/stable', override=True)
         # Force boost version for all dependencies to avoid conflicts
-        self.requires("boost/1.91.0", override=True)
-        self.requires("lz4/1.10.0", force=True)
+        self.requires('boost/1.86.0', override=True)
+        self.requires('lz4/1.10.0', force=True)
 
         if self.options.with_wasmedge:
-            self.requires("wasmedge/0.11.2@xahaud/stable")
+            self.requires('wasmedge/0.11.2@xahaud/stable')
         if self.options.jemalloc:
-            self.requires("jemalloc/5.3.0")
+            self.requires('jemalloc/5.3.0')
         if self.options.rocksdb:
-            self.requires("rocksdb/6.29.5")
+            self.requires('rocksdb/6.29.5')
 
     exports_sources = (
-        "CMakeLists.txt",
-        "bin/getRippledInfo",
-        "cfg/*",
-        "cmake/*",
-        "external/*",
-        "include/*",
-        "src/*",
+        'CMakeLists.txt',
+        'bin/getRippledInfo',
+        'cfg/*',
+        'cmake/*',
+        'external/*',
+        'include/*',
+        'src/*',
     )
 
     def layout(self):
         cmake_layout(self)
         # Fix this setting to follow the default introduced in Conan 1.48
         # to align with our build instructions.
-        self.folders.generators = "build/generators"
-
-    generators = "CMakeDeps"
+        self.folders.generators = 'build/generators'
 
+    generators = 'CMakeDeps'
     def generate(self):
         tc = CMakeToolchain(self)
-        tc.variables["tests"] = self.options.tests
-        tc.variables["assert"] = self.options.assertions
-        tc.variables["coverage"] = self.options.coverage
-        tc.variables["jemalloc"] = self.options.jemalloc
-        tc.variables["rocksdb"] = self.options.rocksdb
-        tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
-        tc.variables["static"] = self.options.static
-        tc.variables["unity"] = self.options.unity
-        tc.variables["xrpld"] = self.options.xrpld
+        tc.variables['tests'] = self.options.tests
+        tc.variables['assert'] = self.options.assertions
+        tc.variables['coverage'] = self.options.coverage
+        tc.variables['jemalloc'] = self.options.jemalloc
+        tc.variables['rocksdb'] = self.options.rocksdb
+        tc.variables['BUILD_SHARED_LIBS'] = self.options.shared
+        tc.variables['static'] = self.options.static
+        tc.variables['unity'] = self.options.unity
+        tc.variables['xrpld'] = self.options.xrpld
         tc.generate()
 
     def build(self):
@@ -170,29 +167,29 @@ class Xrpl(ConanFile):
         cmake.install()
 
     def package_info(self):
-        libxrpl = self.cpp_info.components["libxrpl"]
+        libxrpl = self.cpp_info.components['libxrpl']
         libxrpl.libs = [
-            "xrpl",
-            "xrpl.libpb",
-            "ed25519",
-            "secp256k1",
+            'xrpl',
+            'xrpl.libpb',
+            'ed25519',
+            'secp256k1',
         ]
         # TODO: Fix the protobufs to include each other relative to
         # `include/`, not `include/ripple/proto/`.
-        libxrpl.includedirs = ["include", "include/ripple/proto"]
+        libxrpl.includedirs = ['include', 'include/ripple/proto']
         libxrpl.requires = [
-            "boost::boost",
-            "date::date",
-            "grpc::grpc++",
-            "libarchive::libarchive",
-            "lz4::lz4",
-            "nudb::nudb",
-            "openssl::crypto",
-            "protobuf::libprotobuf",
-            "soci::soci",
-            "sqlite3::sqlite",
-            "xxhash::xxhash",
-            "zlib::zlib",
+            'boost::boost',
+            'date::date',
+            'grpc::grpc++',
+            'libarchive::libarchive',
+            'lz4::lz4',
+            'nudb::nudb',
+            'openssl::crypto',
+            'protobuf::libprotobuf',
+            'soci::soci',
+            'sqlite3::sqlite',
+            'xxhash::xxhash',
+            'zlib::zlib',
         ]
         if self.options.rocksdb:
-            libxrpl.requires.append("rocksdb::librocksdb")
+            libxrpl.requires.append('rocksdb::librocksdb')

hook/extern.h

@@ -2,9 +2,6 @@
 // Generated using generate_extern.sh
 #include <stdint.h>
 #ifndef HOOK_EXTERN
-#ifdef __cplusplus
-extern "C" {
-#endif
 
 extern int32_t __attribute__((noduplicate))
 _g(uint32_t guard_id, uint32_t maxiter);
@@ -339,8 +336,5 @@ prepare(
     uint32_t read_ptr,
     uint32_t read_len);
 
-#ifdef __cplusplus
-}
-#endif
 #define HOOK_EXTERN
 #endif  // HOOK_EXTERN

hook/generate_error.sh

@@ -9,7 +9,7 @@ ENUM_FILE="$SCRIPT_DIR/../include/xrpl/hook/Enum.h"
 echo '// For documentation please see: https://xrpl-hooks.readme.io/reference/'
 echo '// Generated using generate_error.sh'
 echo '#ifndef HOOK_ERROR_CODES'
-sed -n '/enum class hook_return_code/,/};/p' "$ENUM_FILE" |
+sed -n '/enum hook_return_code/,/};/p' "$ENUM_FILE" |
     awk '
         function ltrim(s) { sub(/^[[:space:]]+/, "", s); return s }
         function rtrim(s) { sub(/[[:space:]]+$/, "", s); return s }
@@ -31,7 +31,7 @@ sed -n '/enum class hook_return_code/,/};/p' "$ENUM_FILE" |
 
         {
             line = $0
-            if (line ~ /enum[[:space:]]+class[[:space:]]+hook_return_code/)
+            if (line ~ /enum[[:space:]]+hook_return_code/)
                 next
             if (line ~ /^[[:space:]]*\{/)
                 next

hook/generate_extern.sh

@@ -11,9 +11,6 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
     echo '// Generated using generate_extern.sh'
     echo '#include <stdint.h>'
     echo '#ifndef HOOK_EXTERN'
-    echo '#ifdef __cplusplus'
-    echo 'extern "C" {'
-    echo '#endif'
     echo
     awk '
         function trim(s) {
@@ -22,36 +19,33 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
             return s;
         }
 
-        # Each entry is HOOK_API_DEFINITION(RET, NAME, (PARAMS), AMENDMENT),
-        # possibly spread over several lines. Collect until the parentheses
-        # balance, then split on the first two commas; the parameter tuple
-        # is the first parenthesised group.
-        function emit(s,    i, ret, name, p, q, params) {
-            sub(/^[[:space:]]*HOOK_API_DEFINITION[[:space:]]*\(/, "", s);
-            gsub(/[[:space:]]+/, " ", s);
-            i = index(s, ","); ret = trim(substr(s, 1, i - 1)); s = substr(s, i + 1);
-            i = index(s, ","); name = trim(substr(s, 1, i - 1)); s = substr(s, i + 1);
-            p = index(s, "("); q = index(s, ")");
-            params = trim(substr(s, p + 1, q - p - 1));
-            if (name == "_g")
-                name = "__attribute__((noduplicate)) _g";
-            printf("extern %s %s(%s);\n\n", ret, name, params);
-        }
-
-        /^[[:space:]]*HOOK_API_DEFINITION[[:space:]]*\(/ { buf = ""; collecting = 1; }
-
-        collecting {
-            buf = buf " " $0;
-            if (gsub(/\(/, "(", buf) == gsub(/\)/, ")", buf)) {
-                collecting = 0;
-                emit(buf);
+        {
+            line = $0;
+            
+            # Skip block comments
+            if (line ~ /\/\*/) {
+                next;
+            }
+            
+            # Look for comment lines that start with // and contain function signature
+            if (line ~ /^[[:space:]]*\/\/[[:space:]]*[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]+[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*\(/) {
+                # Remove leading // and trim
+                sub(/^[[:space:]]*\/\/[[:space:]]*/, "", line);
+                line = trim(line);
+                
+                # Check if function name is "_g" to add attribute
+                if (line ~ /[[:space:]]+_g[[:space:]]*\(/) {
+                    # Insert __attribute__((noduplicate)) before _g
+                    sub(/[[:space:]]+_g/, " __attribute__((noduplicate)) _g", line);
+                }
+                
+                # printf("\n");
+                
+                printf("extern %s\n\n", line);
             }
         }
     ' "$APPLY_HOOK"
 
-    echo '#ifdef __cplusplus'
-    echo '}'
-    echo '#endif'
     echo '#define HOOK_EXTERN'
     echo '#endif  // HOOK_EXTERN'
 } | (

hook/generate_lsflags.sh

@@ -1,82 +0,0 @@
-#!/bin/bash
-set -eu
-
-SCRIPT_DIR=$(dirname "$0")
-SCRIPT_DIR=$(cd "$SCRIPT_DIR" && pwd)
-
-RIPPLED_ROOT="$SCRIPT_DIR/../include/xrpl"
-LEDGER_FORMATS="$RIPPLED_ROOT/protocol/LedgerFormats.h"
-
-echo '// Generated using generate_lsflags.sh'
-echo ''
-echo '#ifndef HOOKLSFLAGS_INCLUDED'
-echo '#define HOOKLSFLAGS_INCLUDED 1'
-echo ''
-awk '
-    function ltrim(s) { sub(/^[[:space:]]+/, "", s); return s }
-    function rtrim(s) { sub(/[[:space:]]+$/, "", s); return s }
-    function trim(s) { return rtrim(ltrim(s)) }
-
-    function flush_group() {
-        if (entry_count > 0 && group != "") {
-            printf "enum %s {\n", group
-            for (i = 1; i <= entry_count; i++) {
-                printf "    %s,\n", entries[i]
-            }
-            printf "};\n"
-        }
-        delete entries
-        entry_count = 0
-    }
-
-    /enum LedgerSpecificFlags \{/ { inside = 1; next }
-    inside && /^\};/ { inside = 0; flush_group(); next }
-    !inside { next }
-
-    # Group header comments: // ltFOO or // remarks
-    /^[[:space:]]*\/\/[[:space:]]*(lt[A-Z_]+|remarks)[[:space:]]*$/ {
-        flush_group()
-        line = $0
-        sub(/.*\/\/[[:space:]]*/, "", line)
-        group = trim(line)
-        next
-    }
-
-    # Skip pure comment lines (not group headers)
-    /^[[:space:]]*\/\// { next }
-
-    # Skip blank lines
-    /^[[:space:]]*$/ { next }
-
-    # Accumulate flag lines (handle multi-line values)
-    {
-        line = $0
-        # Strip inline comments
-        sub(/\/\/.*/, "", line)
-        line = trim(line)
-        if (line == "") next
-
-        if (pending != "") {
-            pending = pending " " line
-        } else {
-            pending = line
-        }
-
-        # If line ends with comma, the entry is complete
-        if (pending ~ /,$/) {
-            # Remove trailing comma
-            sub(/,$/, "", pending)
-            entries[++entry_count] = pending
-            pending = ""
-        }
-    }
-
-    BEGIN {
-        inside = 0
-        group = ""
-        pending = ""
-        entry_count = 0
-    }
-' "$LEDGER_FORMATS"
-echo ''
-echo '#endif // HOOKLSFLAGS_INCLUDED'

hook/generate_txflags.sh

@@ -1,25 +0,0 @@
-#!/bin/bash
-set -eu
-
-SCRIPT_DIR=$(dirname "$0")
-SCRIPT_DIR=$(cd "$SCRIPT_DIR" && pwd)
-
-RIPPLED_ROOT="$SCRIPT_DIR/../include/xrpl"
-TX_FLAGS="$RIPPLED_ROOT/protocol/TxFlags.h"
-
-echo '// Generated using generate_txflags.sh'
-echo '#include "ls_flags.h"'
-echo '#include <stdint.h>'
-echo ''
-cat "$TX_FLAGS" |
-    awk '
-        /^[[:space:]]*enum / {
-            if (count > 0) print ""
-            inside = 1
-            count++
-        }
-        inside {
-            print
-            if (/};/) inside = 0
-        }
-    '

hook/hookapi.h

@@ -38,7 +38,6 @@
 #define KEYLET_HOOK_DEFINITION 24
 #define KEYLET_HOOK_STATE_DIR 25
 #define KEYLET_CRON 26
-#define KEYLET_MANIFEST 37
 
 #define COMPARE_EQUAL 1U
 #define COMPARE_LESS 2U
@@ -50,7 +49,4 @@
 #include "macro.h"
 #include "tts.h"
 
-#include "ls_flags.h"
-#include "tx_flags.h"
-
 #endif

hook/ls_flags.h

@@ -1,75 +0,0 @@
-// Generated using generate_lsflags.sh
-
-#ifndef HOOKLSFLAGS_INCLUDED
-#define HOOKLSFLAGS_INCLUDED 1
-
-enum ltACCOUNT_ROOT {
-    lsfPasswordSpent = 0x00010000,
-    lsfRequireDestTag = 0x00020000,
-    lsfRequireAuth = 0x00040000,
-    lsfDisallowXRP = 0x00080000,
-    lsfDisableMaster = 0x00100000,
-    lsfNoFreeze = 0x00200000,
-    lsfGlobalFreeze = 0x00400000,
-    lsfDefaultRipple = 0x00800000,
-    lsfDepositAuth = 0x01000000,
-    lsfTshCollect = 0x02000000,
-    lsfDisallowIncomingNFTokenOffer = 0x04000000,
-    lsfDisallowIncomingCheck = 0x08000000,
-    lsfDisallowIncomingPayChan = 0x10000000,
-    lsfDisallowIncomingTrustline = 0x20000000,
-    lsfURITokenIssuer = 0x40000000,
-    lsfDisallowIncomingRemit = 0x80000000,
-    lsfAllowTrustLineClawback = 0x00001000,
-};
-enum ltOFFER {
-    lsfPassive = 0x00010000,
-    lsfSell = 0x00020000,
-};
-enum ltRIPPLE_STATE {
-    lsfLowReserve = 0x00010000,
-    lsfHighReserve = 0x00020000,
-    lsfLowAuth = 0x00040000,
-    lsfHighAuth = 0x00080000,
-    lsfLowNoRipple = 0x00100000,
-    lsfHighNoRipple = 0x00200000,
-    lsfLowFreeze = 0x00400000,
-    lsfHighFreeze = 0x00800000,
-    lsfLowDeepFreeze = 0x02000000,
-    lsfHighDeepFreeze = 0x04000000,
-    lsfAMMNode = 0x01000000,
-};
-enum ltSIGNER_LIST {
-    lsfOneOwnerCount = 0x00010000,
-};
-enum ltDIR_NODE {
-    lsfNFTokenBuyOffers = 0x00000001,
-    lsfNFTokenSellOffers = 0x00000002,
-    lsfEmittedDir = 0x00000004,
-};
-enum ltNFTOKEN_OFFER {
-    lsfSellNFToken = 0x00000001,
-};
-enum ltURI_TOKEN {
-    lsfBurnable = 0x00000001,
-};
-enum remarks {
-    lsfImmutable = 1,
-};
-enum ltMPTOKEN_ISSUANCE {
-    lsfMPTLocked = 0x00000001,
-    lsfMPTCanLock = 0x00000002,
-    lsfMPTRequireAuth = 0x00000004,
-    lsfMPTCanEscrow = 0x00000008,
-    lsfMPTCanTrade = 0x00000010,
-    lsfMPTCanTransfer = 0x00000020,
-    lsfMPTCanClawback = 0x00000040,
-};
-enum ltMPTOKEN {
-    lsfMPTAuthorized = 0x00000002,
-};
-enum ltCREDENTIAL {
-    lsfAccepted = 0x00010000,
-};
-
-#endif // HOOKLSFLAGS_INCLUDED

hook/sfcodes.h

@@ -152,7 +152,6 @@
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
 #define sfDomainID ((5U << 16U) + 37U)
-#define sfManifestID ((5U << 16U) + 91U)
 #define sfHookOnOutgoing ((5U << 16U) + 93U)
 #define sfHookOnIncoming ((5U << 16U) + 94U)
 #define sfCron ((5U << 16U) + 95U)
@@ -190,7 +189,6 @@
 #define sfSignatureReward ((6U << 16U) + 29U)
 #define sfMinAccountCreateAmount ((6U << 16U) + 30U)
 #define sfLPTokenBalance ((6U << 16U) + 31U)
-#define sfTrustLineRewardAccumulator ((6U << 16U) + 99U)
 #define sfPublicKey ((7U << 16U) + 1U)
 #define sfMessageKey ((7U << 16U) + 2U)
 #define sfSigningPubKey ((7U << 16U) + 3U)
@@ -222,7 +220,6 @@
 #define sfProvider ((7U << 16U) + 30U)
 #define sfMPTokenMetadata ((7U << 16U) + 31U)
 #define sfCredentialType ((7U << 16U) + 32U)
-#define sfHookName ((7U << 16U) + 97U)
 #define sfRemarkValue ((7U << 16U) + 98U)
 #define sfRemarkName ((7U << 16U) + 99U)
 #define sfAccount ((8U << 16U) + 1U)
@@ -258,7 +255,6 @@
 #define sfIssuingChainIssue ((24U << 16U) + 2U)
 #define sfAsset ((24U << 16U) + 3U)
 #define sfAsset2 ((24U << 16U) + 4U)
-#define sfClaimCurrency ((24U << 16U) + 5U)
 #define sfXChainBridge ((25U << 16U) + 1U)
 #define sfTransactionMetaData ((14U << 16U) + 2U)
 #define sfCreatedNode ((14U << 16U) + 3U)
@@ -278,6 +274,7 @@
 #define sfDisabledValidator ((14U << 16U) + 19U)
 #define sfEmittedTxn ((14U << 16U) + 20U)
 #define sfHookExecution ((14U << 16U) + 21U)
+#define sfHookDefinition ((14U << 16U) + 22U)
 #define sfHookParameter ((14U << 16U) + 23U)
 #define sfHookGrant ((14U << 16U) + 24U)
 #define sfVoteEntry ((14U << 16U) + 25U)
@@ -289,7 +286,6 @@
 #define sfXChainCreateAccountAttestationCollectionElement ((14U << 16U) + 31U)
 #define sfPriceData ((14U << 16U) + 32U)
 #define sfCredential ((14U << 16U) + 33U)
-#define sfManifest ((14U << 16U) + 90U)
 #define sfAmountEntry ((14U << 16U) + 91U)
 #define sfMintURIToken ((14U << 16U) + 92U)
 #define sfHookEmission ((14U << 16U) + 93U)
@@ -297,8 +293,6 @@
 #define sfActiveValidator ((14U << 16U) + 95U)
 #define sfGenesisMint ((14U << 16U) + 96U)
 #define sfRemark ((14U << 16U) + 97U)
-#define sfHighReward ((14U << 16U) + 98U)
-#define sfLowReward ((14U << 16U) + 99U)
 #define sfSigners ((15U << 16U) + 3U)
 #define sfSignerEntries ((15U << 16U) + 4U)
 #define sfTemplate ((15U << 16U) + 5U)

hook/tts.h

@@ -61,7 +61,6 @@
 #define ttNFTOKEN_MODIFY 70
 #define ttPERMISSIONED_DOMAIN_SET 71
 #define ttPERMISSIONED_DOMAIN_DELETE 72
-#define ttMANIFEST_SET 91
 #define ttCRON 92
 #define ttCRON_SET 93
 #define ttREMARKS_SET 94

hook/tx_flags.h

@@ -1,117 +0,0 @@
-// Generated using generate_txflags.sh
-#include "ls_flags.h"
-#include <stdint.h>
-
-enum UniversalFlags : uint32_t {
-    tfFullyCanonicalSig = 0x80000000,
-};
-
-enum AccountSetFlags : uint32_t {
-    tfRequireDestTag = 0x00010000,
-    tfOptionalDestTag = 0x00020000,
-    tfRequireAuth = 0x00040000,
-    tfOptionalAuth = 0x00080000,
-    tfDisallowXRP = 0x00100000,
-    tfAllowXRP = 0x00200000,
-};
-
-enum AccountFlags : uint32_t {
-    asfRequireDest = 1,
-    asfRequireAuth = 2,
-    asfDisallowXRP = 3,
-    asfDisableMaster = 4,
-    asfAccountTxnID = 5,
-    asfNoFreeze = 6,
-    asfGlobalFreeze = 7,
-    asfDefaultRipple = 8,
-    asfDepositAuth = 9,
-    asfAuthorizedNFTokenMinter = 10,
-    asfTshCollect = 11,
-    asfDisallowIncomingNFTokenOffer = 12,
-    asfDisallowIncomingCheck = 13,
-    asfDisallowIncomingPayChan = 14,
-    asfDisallowIncomingTrustline = 15,
-    asfDisallowIncomingRemit = 16,
-    asfAllowTrustLineClawback = 17,
-};
-
-enum OfferCreateFlags : uint32_t {
-    tfPassive = 0x00010000,
-    tfImmediateOrCancel = 0x00020000,
-    tfFillOrKill = 0x00040000,
-    tfSell = 0x00080000,
-};
-
-enum PaymentFlags : uint32_t {
-    tfNoRippleDirect = 0x00010000,
-    tfPartialPayment = 0x00020000,
-    tfLimitQuality = 0x00040000,
-};
-
-enum TrustSetFlags : uint32_t {
-    tfSetfAuth = 0x00010000,
-    tfSetNoRipple = 0x00020000,
-    tfClearNoRipple = 0x00040000,
-    tfSetFreeze = 0x00100000,
-    tfClearFreeze = 0x00200000,
-    tfSetDeepFreeze = 0x00400000,
-    tfClearDeepFreeze = 0x00800000
-};
-
-enum EnableAmendmentFlags : uint32_t {
-    tfGotMajority = 0x00010000,
-    tfLostMajority = 0x00020000,
-    tfTestSuite = 0x80000000,
-};
-
-enum PaymentChannelClaimFlags : uint32_t {
-    tfRenew = 0x00010000,
-    tfClose = 0x00020000,
-};
-
-enum NFTokenMintFlags : uint32_t {
-    tfBurnable = 0x00000001,
-    tfOnlyXRP = 0x00000002,
-    tfTrustLine = 0x00000004,
-    tfTransferable = 0x00000008,
-    tfMutable = 0x00000010,
-    tfStrongTSH = 0x00008000,
-};
-
-enum MPTokenIssuanceCreateFlags : uint32_t {
-    tfMPTCanLock = lsfMPTCanLock,
-    tfMPTRequireAuth = lsfMPTRequireAuth,
-    tfMPTCanEscrow = lsfMPTCanEscrow,
-    tfMPTCanTrade = lsfMPTCanTrade,
-    tfMPTCanTransfer = lsfMPTCanTransfer,
-    tfMPTCanClawback = lsfMPTCanClawback,
-};
-
-enum MPTokenAuthorizeFlags : uint32_t {
-    tfMPTUnauthorize = 0x00000001,
-};
-
-enum MPTokenIssuanceSetFlags : uint32_t {
-    tfMPTLock = 0x00000001,
-    tfMPTUnlock = 0x00000002,
-};
-
-enum NFTokenCreateOfferFlags : uint32_t {
-    tfSellNFToken = 0x00000001,
-};
-
-enum ClaimRewardFlags : uint32_t {
-    tfOptOut = 0x00000001,
-};
-
-enum CronSetFlags : uint32_t {
-    tfCronUnset = 0x00000001,
-};
-
-enum AMMClawbackFlags : uint32_t {
-    tfClawTwoAssets = 0x00000001,
-};
-
-enum BridgeModifyFlags : uint32_t {
-    tfClearAccountCreateAmount = 0x00010000,
-};

include/xrpl/basics/MathUtilities.h

@@ -23,66 +23,9 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
-#include <cstdint>
-#include <limits>
-#include <optional>
 
 namespace ripple {
 
-/** Add two signed 64-bit integers, returning std::nullopt when the exact
- *  mathematical sum is not representable in std::int64_t.
- */
-[[nodiscard]] constexpr std::optional<std::int64_t>
-checkedAdd(std::int64_t a, std::int64_t b) noexcept
-{
-    using L = std::numeric_limits<std::int64_t>;
-
-    if ((b > 0 && a > L::max() - b) || (b < 0 && a < L::min() - b))
-        return std::nullopt;
-
-    return a + b;
-}
-
-/** Subtract two signed 64-bit integers, returning std::nullopt when the exact
- *  mathematical difference is not representable in std::int64_t.
- */
-[[nodiscard]] constexpr std::optional<std::int64_t>
-checkedSub(std::int64_t a, std::int64_t b) noexcept
-{
-    using L = std::numeric_limits<std::int64_t>;
-
-    if ((b > 0 && a < L::min() + b) || (b < 0 && a > L::max() + b))
-        return std::nullopt;
-
-    return a - b;
-}
-
-namespace detail {
-using i64_limits = std::numeric_limits<std::int64_t>;
-
-static_assert(checkedAdd(0, 0) == 0);
-static_assert(checkedAdd(1, -1) == 0);
-static_assert(checkedAdd(-5, 2) == -3);
-static_assert(!checkedAdd(i64_limits::max(), 1).has_value());
-static_assert(!checkedAdd(i64_limits::min(), -1).has_value());
-static_assert(checkedAdd(i64_limits::max() - 1, 1) == i64_limits::max());
-static_assert(checkedAdd(i64_limits::min(), i64_limits::max()) == -1);
-static_assert(checkedAdd(i64_limits::max(), i64_limits::min()) == -1);
-static_assert(!checkedAdd(i64_limits::max(), i64_limits::max()).has_value());
-static_assert(!checkedAdd(i64_limits::min(), i64_limits::min()).has_value());
-
-static_assert(checkedSub(0, 0) == 0);
-static_assert(checkedSub(1, 1) == 0);
-static_assert(checkedSub(-5, 2) == -7);
-static_assert(checkedSub(-5, -2) == -3);
-static_assert(!checkedSub(i64_limits::min(), 1).has_value());
-static_assert(!checkedSub(i64_limits::max(), -1).has_value());
-static_assert(checkedSub(i64_limits::min() + 1, 1) == i64_limits::min());
-static_assert(checkedSub(-1, i64_limits::max()) == i64_limits::min());
-static_assert(!checkedSub(i64_limits::max(), i64_limits::min()).has_value());
-static_assert(!checkedSub(i64_limits::min(), i64_limits::max()).has_value());
-}  // namespace detail
-
 /** Calculate one number divided by another number in percentage.
  * The result is rounded up to the next integer, and capped in the range [0,100]
  * E.g. calculatePercent(1, 100) = 1 because 1/100 = 0.010000

include/xrpl/basics/ReaderPreferringSharedMutex.h

@@ -1,105 +0,0 @@
-#pragma once
-
-#include <shared_mutex>
-
-// On Linux (glibc), std::shared_mutex wraps pthread_rwlock_t initialised
-// with PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP.  This means a
-// pending exclusive lock() blocks new shared (reader) acquisitions,
-// causing reader starvation when writers contend frequently.
-//
-// On macOS / ARM (libc++), std::shared_mutex is already reader-preferring,
-// so the same code behaves differently across platforms.
-//
-// This header provides ReaderPreferringSharedMutex:
-//   - On Linux it wraps pthread_rwlock_t initialised with
-//     PTHREAD_RWLOCK_PREFER_READER_NP, matching macOS semantics.
-//   - On all other platforms it is a type alias for std::shared_mutex.
-//
-// The interface is identical to std::shared_mutex, so it works with
-// std::shared_lock and std::unique_lock.
-
-#if defined(__linux__)
-
-#include <cerrno>
-#include <pthread.h>
-#include <system_error>
-
-namespace ripple {
-
-class ReaderPreferringSharedMutex
-{
-    pthread_rwlock_t rwlock_;
-
-public:
-    ReaderPreferringSharedMutex()
-    {
-        pthread_rwlockattr_t attr;
-        pthread_rwlockattr_init(&attr);
-        pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_READER_NP);
-        int rc = pthread_rwlock_init(&rwlock_, &attr);
-        pthread_rwlockattr_destroy(&attr);
-        if (rc != 0)
-            throw std::system_error(
-                rc, std::system_category(), "pthread_rwlock_init");
-    }
-
-    ~ReaderPreferringSharedMutex()
-    {
-        pthread_rwlock_destroy(&rwlock_);
-    }
-
-    ReaderPreferringSharedMutex(ReaderPreferringSharedMutex const&) = delete;
-    ReaderPreferringSharedMutex&
-    operator=(ReaderPreferringSharedMutex const&) = delete;
-
-    // Exclusive (writer) locking
-    void
-    lock()
-    {
-        pthread_rwlock_wrlock(&rwlock_);
-    }
-
-    bool
-    try_lock()
-    {
-        return pthread_rwlock_trywrlock(&rwlock_) == 0;
-    }
-
-    void
-    unlock()
-    {
-        pthread_rwlock_unlock(&rwlock_);
-    }
-
-    // Shared (reader) locking
-    void
-    lock_shared()
-    {
-        pthread_rwlock_rdlock(&rwlock_);
-    }
-
-    bool
-    try_lock_shared()
-    {
-        return pthread_rwlock_tryrdlock(&rwlock_) == 0;
-    }
-
-    void
-    unlock_shared()
-    {
-        pthread_rwlock_unlock(&rwlock_);
-    }
-};
-
-}  // namespace ripple
-
-#else  // !__linux__
-
-namespace ripple {
-
-// macOS, Windows, etc. — std::shared_mutex is already reader-preferring.
-using ReaderPreferringSharedMutex = std::shared_mutex;
-
-}  // namespace ripple
-
-#endif

include/xrpl/basics/ResolverAsio.h

@@ -22,8 +22,7 @@
 
 #include <xrpl/basics/Resolver.h>
 #include <xrpl/beast/utility/Journal.h>
-
-#include <boost/asio/io_context.hpp>
+#include <boost/asio/io_service.hpp>
 
 namespace ripple {
 
@@ -33,7 +32,7 @@ public:
     explicit ResolverAsio() = default;
 
     static std::unique_ptr<ResolverAsio>
-    New(boost::asio::io_context&, beast::Journal);
+    New(boost::asio::io_service&, beast::Journal);
 };
 
 }  // namespace ripple

include/xrpl/basics/StringUtilities.h

@@ -77,7 +77,7 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     if (strSize & 1)
     {
-        int c = unxtab[static_cast<unsigned char>(*iter++)];
+        int c = unxtab[*iter++];
 
         if (c < 0)
             return {};
@@ -87,12 +87,12 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     while (iter != end)
     {
-        int cHigh = unxtab[static_cast<unsigned char>(*iter++)];
+        int cHigh = unxtab[*iter++];
 
         if (cHigh < 0)
             return {};
 
-        int cLow = unxtab[static_cast<unsigned char>(*iter++)];
+        int cLow = unxtab[*iter++];
 
         if (cLow < 0)
             return {};

include/xrpl/basics/UTF8.h

@@ -1,60 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2025 XRPL Labs
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_UTF8_H_INCLUDED
-#define RIPPLE_BASICS_UTF8_H_INCLUDED
-
-#include <xrpl/basics/Slice.h>
-
-namespace ripple {
-
-/** Check that a byte sequence is well-formed UTF-8, excluding the two
-    noncharacters U+FFFE and U+FFFF.
-
-    Rejects:
-      - overlong encodings;
-      - UTF-16 surrogate halves (U+D800..U+DFFF);
-      - scalar values above U+10FFFF, and 0xF5..0xFF lead bytes;
-      - stray continuation bytes;
-      - multi-byte sequences truncated by the end of the buffer;
-      - U+FFFE and U+FFFF (EF BF BE, EF BF BF).
-
-    U+FFFE and U+FFFF are well-formed, but have no use in a URI or a name
-    and exist to be misread: U+FFFE is a byte-swapped BOM, so a client that
-    transcodes to UTF-16/32 and sniffs the byte order can be pushed into
-    decoding the rest of the string with the wrong endianness, and both are
-    commonly used as in-band sentinels. They have always been rejected by
-    URIToken and HookName validation, and this function preserves that.
-
-    This is consensus-critical. For every input the previous decoder could
-    evaluate without reading past the end of the buffer, the result is
-    identical to it. The only difference is that truncated trailing
-    sequences, where the previous decoder read out of bounds, are now always
-    rejected. Any further change to what this accepts needs an amendment.
-
-    @param s The bytes to check.
-
-    @note Total: every byte read is within s.
-*/
-bool
-isValidUTF8(Slice const& s) noexcept;
-
-}  // namespace ripple
-
-#endif

include/xrpl/beast/asio/io_latency_probe.h

@@ -22,8 +22,7 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 #include <boost/asio/basic_waitable_timer.hpp>
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/post.hpp>
+#include <boost/asio/io_service.hpp>
 
 #include <chrono>
 #include <condition_variable>
@@ -32,7 +31,7 @@
 
 namespace beast {
 
-/** Measures handler latency on an io_context queue. */
+/** Measures handler latency on an io_service queue. */
 template <class Clock>
 class io_latency_probe
 {
@@ -44,12 +43,12 @@ private:
     std::condition_variable_any m_cond;
     std::size_t m_count;
     duration const m_period;
-    boost::asio::io_context& m_ios;
+    boost::asio::io_service& m_ios;
     boost::asio::basic_waitable_timer<std::chrono::steady_clock> m_timer;
     bool m_cancel;
 
 public:
-    io_latency_probe(duration const& period, boost::asio::io_context& ios)
+    io_latency_probe(duration const& period, boost::asio::io_service& ios)
         : m_count(1)
         , m_period(period)
         , m_ios(ios)
@@ -64,16 +63,16 @@ public:
         cancel(lock, true);
     }
 
-    /** Return the io_context associated with the latency probe. */
+    /** Return the io_service associated with the latency probe. */
     /** @{ */
-    boost::asio::io_context&
-    get_io_context()
+    boost::asio::io_service&
+    get_io_service()
     {
         return m_ios;
     }
 
-    boost::asio::io_context const&
-    get_io_context() const
+    boost::asio::io_service const&
+    get_io_service() const
     {
         return m_ios;
     }
@@ -109,10 +108,8 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        boost::asio::post(
-            m_ios,
-            sample_op<Handler>(
-                std::forward<Handler>(handler), Clock::now(), false, this));
+        m_ios.post(sample_op<Handler>(
+            std::forward<Handler>(handler), Clock::now(), false, this));
     }
 
     /** Initiate continuous i/o latency sampling.
@@ -126,10 +123,8 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        boost::asio::post(
-            m_ios,
-            sample_op<Handler>(
-                std::forward<Handler>(handler), Clock::now(), true, this));
+        m_ios.post(sample_op<Handler>(
+            std::forward<Handler>(handler), Clock::now(), true, this));
     }
 
 private:
@@ -240,13 +235,12 @@ private:
                     // The latency is too high to maintain the desired
                     // period so don't bother with a timer.
                     //
-                    boost::asio::post(
-                        m_probe->m_ios,
+                    m_probe->m_ios.post(
                         sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
                 else
                 {
-                    m_probe->m_timer.expires_after(when - now);
+                    m_probe->m_timer.expires_from_now(when - now);
                     m_probe->m_timer.async_wait(
                         sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
@@ -259,8 +253,7 @@ private:
             if (!m_probe)
                 return;
             typename Clock::time_point const now(Clock::now());
-            boost::asio::post(
-                m_probe->m_ios,
+            m_probe->m_ios.post(
                 sample_op<Handler>(m_handler, now, m_repeat, m_probe));
         }
     };

include/xrpl/beast/test/yield_to.h

@@ -8,12 +8,9 @@
 #ifndef BEAST_TEST_YIELD_TO_HPP
 #define BEAST_TEST_YIELD_TO_HPP
 
-#include <boost/asio/executor_work_guard.hpp>
-#include <boost/asio/io_context.hpp>
+#include <boost/asio/io_service.hpp>
 #include <boost/asio/spawn.hpp>
 #include <boost/optional.hpp>
-#include <boost/thread/csbl/memory/allocator_arg.hpp>
-
 #include <condition_variable>
 #include <functional>
 #include <mutex>
@@ -32,12 +29,10 @@ namespace test {
 class enable_yield_to
 {
 protected:
-    boost::asio::io_context ios_;
+    boost::asio::io_service ios_;
 
 private:
-    boost::optional<boost::asio::executor_work_guard<
-        boost::asio::io_context::executor_type>>
-        work_;
+    boost::optional<boost::asio::io_service::work> work_;
     std::vector<std::thread> threads_;
     std::mutex m_;
     std::condition_variable cv_;
@@ -47,8 +42,7 @@ public:
     /// The type of yield context passed to functions.
     using yield_context = boost::asio::yield_context;
 
-    explicit enable_yield_to(std::size_t concurrency = 1)
-        : work_(boost::asio::make_work_guard(ios_))
+    explicit enable_yield_to(std::size_t concurrency = 1) : work_(ios_)
     {
         threads_.reserve(concurrency);
         while (concurrency--)
@@ -62,9 +56,9 @@ public:
             t.join();
     }
 
-    /// Return the `io_context` associated with the object
-    boost::asio::io_context&
-    get_io_context()
+    /// Return the `io_service` associated with the object
+    boost::asio::io_service&
+    get_io_service()
     {
         return ios_;
     }
@@ -117,18 +111,13 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
 {
     boost::asio::spawn(
         ios_,
-        boost::allocator_arg,
-        boost::context::fixedsize_stack(2 * 1024 * 1024),
         [&](yield_context yield) {
             f(yield);
             std::lock_guard lock{m_};
             if (--running_ == 0)
                 cv_.notify_all();
         },
-        [](std::exception_ptr e) {
-            if (e)
-                std::rethrow_exception(e);
-        });
+        boost::coroutines::attributes(2 * 1024 * 1024));
     spawn(fn...);
 }
 

include/xrpl/hook/Enum.h

@@ -16,7 +16,6 @@
 #define featureHooksUpdate1 "1"
 #define featureHooksUpdate2 "1"
 #define fix20250131 "1"
-#define fixGuardDepth32 "1"
 namespace hook_api {
 struct Rules
 {
@@ -313,7 +312,6 @@ enum keylet_code : uint32_t {
     MPTOKEN = 34,
     CREDENTIAL = 35,
     PERMISSIONED_DOMAIN = 36,
-    MANIFEST = 37,
 };
 }
 
@@ -321,7 +319,7 @@ namespace compare_mode {
 enum compare_mode : uint32_t { EQUAL = 1, LESS = 2, GREATER = 4 };
 }
 
-enum class hook_return_code : int64_t {
+enum hook_return_code : int64_t {
     SUCCESS =
         0,  // return codes > 0 are reserved for hook apis to return "success"
     OUT_OF_BOUNDS =
@@ -383,12 +381,12 @@ enum class hook_return_code : int64_t {
     INVALID_KEY = -41,   // user supplied key was not valid
     NOT_A_STRING = -42,  // nul terminator missing from a string argument
     MEM_OVERLAP = -43,   // one or more specified buffers are the same memory
-    TOO_MANY_STATE_MODIFICATIONS = -44,  // more than 256 modified state
+    TOO_MANY_STATE_MODIFICATIONS = -44,  // more than 5000 modified state
                                          // entires in the combined hook chains
     TOO_MANY_NAMESPACES = -45
 };
 
-enum class ExitType : uint8_t {
+enum ExitType : uint8_t {
     UNSET = 0,
     WASM_ERROR = 1,
     ROLLBACK = 2,
@@ -404,18 +402,6 @@ const double fee_base_multiplier = 1.1f;
 
 using APIWhitelist = std::map<std::string, std::vector<uint8_t>>;
 
-namespace detail {
-template <class T>
-constexpr uint8_t wasmTypeCode = sizeof(T) == 8 ? 0x7EU : 0x7FU;
-
-template <class R, class... Args>
-std::vector<uint8_t>
-wasmSignature(R (*)(Args...))
-{
-    return {wasmTypeCode<R>, wasmTypeCode<Args>...};
-}
-}  // namespace detail
-
 // RH NOTE: Find descriptions of api functions in ./impl/applyHook.cpp and
 // hookapi.h (include for hooks) this is a map of the api name to its return
 // code (vec[0] and its parameters vec[>0]) as wasm type codes
@@ -427,15 +413,25 @@ getImportWhitelist(Rules const& rules)
 #pragma push_macro("HOOK_API_DEFINITION")
 #undef HOOK_API_DEFINITION
 
+#define int64_t 0x7EU
+#define int32_t 0x7FU
+#define uint32_t 0x7FU
+
+#define HOOK_WRAP_PARAMS(...) __VA_ARGS__
+
 #define HOOK_API_DEFINITION(                                \
     RETURN_TYPE, FUNCTION_NAME, PARAMS_TUPLE, AMENDMENT)    \
     if (AMENDMENT == uint256{} || rules.enabled(AMENDMENT)) \
-        whitelist[#FUNCTION_NAME] =                         \
-            detail::wasmSignature((RETURN_TYPE(*) PARAMS_TUPLE) nullptr);
+        whitelist[#FUNCTION_NAME] = {                       \
+            RETURN_TYPE, HOOK_WRAP_PARAMS PARAMS_TUPLE};
 
 #include "hook_api.macro"
 
 #undef HOOK_API_DEFINITION
+#undef HOOK_WRAP_PARAMS
+#undef int64_t
+#undef int32_t
+#undef uint32_t
 #pragma pop_macro("HOOK_API_DEFINITION")
 
     return whitelist;
@@ -447,7 +443,6 @@ getImportWhitelist(Rules const& rules)
 
 enum GuardRulesVersion : uint64_t {
     GuardRuleFix20250131 = 0x00000001,
-    GuardRuleDepth32 = 0x00000002,
 };
 
 inline uint64_t
@@ -456,8 +451,6 @@ getGuardRulesVersion(Rules const& rules)
     uint64_t version = 0;
     if (rules.enabled(fix20250131))
         version |= GuardRuleFix20250131;
-    if (rules.enabled(fixGuardDepth32))
-        version |= GuardRuleDepth32;
     return version;
 }
 

include/xrpl/hook/Guard.h

@@ -87,7 +87,7 @@ parseSignedLeb128(
         }
         *end_offset = i;
         if (shift < 64 && (b & 0x40U))
-            val |= (~int64_t{0} << shift);
+            val |= (~0 << shift);
 
         return val;
     }
@@ -204,13 +204,9 @@ struct WasmBlkInf
     }
 // compute worst case execution time
 inline uint64_t
-compute_wce(
-    const WasmBlkInf* blk,
-    int level,
-    int max_level,
-    bool* recursion_limit_reached)
+compute_wce(const WasmBlkInf* blk, int level, bool* recursion_limit_reached)
 {
-    if (level > max_level)
+    if (level > 16)
     {
         *recursion_limit_reached = true;
         return 0;
@@ -237,8 +233,8 @@ compute_wce(
 
     if (blk->children.size() > 0)
         for (auto const& child : blk->children)
-            worst_case_execution += compute_wce(
-                child, level + 1, max_level, recursion_limit_reached);
+            worst_case_execution +=
+                compute_wce(child, level + 1, recursion_limit_reached);
 
     if (parent == 0 ||
         parent->iteration_bound ==
@@ -792,17 +788,12 @@ check_guard(
     }
 
     bool recursion_limit_reached = false;
-    int max_level = 16;
-    if (rulesVersion & hook_api::GuardRuleDepth32)
-        max_level = 32;
-    uint64_t wce =
-        compute_wce(&(*root), 0, max_level, &recursion_limit_reached);
+    uint64_t wce = compute_wce(&(*root), 0, &recursion_limit_reached);
     if (recursion_limit_reached)
     {
         GUARDLOG(hook::log::NESTING_LIMIT)
             << "GuardCheck "
-            << "Maximum allowable depth of blocks reached (" << max_level
-            << " levels). Flatten "
+            << "Maximum allowable depth of blocks reached (16 levels). Flatten "
                "your loops and conditions!.\n";
         return {};
     }

include/xrpl/hook/Macro.h

@@ -89,69 +89,58 @@
 
 #define WASM_VAL_TYPE(T, b) CAT2(TYP_, T)
 
-#define UNSIGNED_TYPE(T) std::make_unsigned_t<T>
-
-#define DECLARE_HOOK_FUNCTION(R, F, ...)                          \
-    std::variant<UNSIGNED_TYPE(R), hook_api::hook_return_code> F( \
-        hook::HookContext& hookCtx,                               \
-        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(  \
-            COMMA __VA_ARGS__));                                  \
-    extern WasmEdge_Result WasmFunction##F(                       \
-        void* data_ptr,                                           \
-        const WasmEdge_CallingFrameContext* frameCtx,             \
-        const WasmEdge_Value* in,                                 \
-        WasmEdge_Value* out);                                     \
-    extern WasmEdge_ValType WasmFunctionParams##F[];              \
-    extern WasmEdge_ValType WasmFunctionResult##F[];              \
-    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F;     \
+#define DECLARE_HOOK_FUNCTION(R, F, ...)                         \
+    R F(hook::HookContext& hookCtx,                              \
+        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__( \
+            COMMA __VA_ARGS__));                                 \
+    extern WasmEdge_Result WasmFunction##F(                      \
+        void* data_ptr,                                          \
+        const WasmEdge_CallingFrameContext* frameCtx,            \
+        const WasmEdge_Value* in,                                \
+        WasmEdge_Value* out);                                    \
+    extern WasmEdge_ValType WasmFunctionParams##F[];             \
+    extern WasmEdge_ValType WasmFunctionResult##F[];             \
+    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F;    \
     extern WasmEdge_String WasmFunctionName##F;
 
-#define DEFINE_HOOK_FUNCTION(R, F, ...)                                        \
-    WasmEdge_Result hook_api::WasmFunction##F(                                 \
-        void* data_ptr,                                                        \
-        const WasmEdge_CallingFrameContext* frameCtx,                          \
-        const WasmEdge_Value* in,                                              \
-        WasmEdge_Value* out)                                                   \
-    {                                                                          \
-        __VA_OPT__(int _stack = 0;)                                            \
-        __VA_OPT__(FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);)                      \
-        hook::HookContext* hookCtx =                                           \
-            reinterpret_cast<hook::HookContext*>(data_ptr);                    \
-        auto const& return_code = hook_api::F(                                 \
-            *hookCtx,                                                          \
-            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)               \
-                __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));                   \
-        if (std::holds_alternative<hook_api::hook_return_code>(return_code) && \
-            (std::get<hook_api::hook_return_code>(return_code) ==              \
-                 RC_ROLLBACK ||                                                \
-             std::get<hook_api::hook_return_code>(return_code) == RC_ACCEPT))  \
-            return WasmEdge_Result_Terminate;                                  \
-        out[0] = RET_ASSIGN(                                                   \
-            R,                                                                 \
-            std::holds_alternative<UNSIGNED_TYPE(R)>(return_code)              \
-                ? std::get<UNSIGNED_TYPE(R)>(return_code)                      \
-                : R(std::get<hook_api::hook_return_code>(return_code)));       \
-        return WasmEdge_Result_Success;                                        \
-    };                                                                         \
-    WasmEdge_ValType hook_api::WasmFunctionParams##F[] = {                     \
-        __VA_OPT__(FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__))};                  \
-    WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {                    \
-        WASM_VAL_TYPE(R, dummy)};                                              \
-    WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =              \
-        WasmEdge_FunctionTypeCreate(                                           \
-            WasmFunctionParams##F,                                             \
-            VA_NARGS(NULL __VA_OPT__(, __VA_ARGS__)),                          \
-            WasmFunctionResult##F,                                             \
-            1);                                                                \
-    WasmEdge_String hook_api::WasmFunctionName##F =                            \
-        WasmEdge_StringCreateByCString(#F);                                    \
-    std::variant<UNSIGNED_TYPE(R), hook_api::hook_return_code> hook_api::F(    \
-        hook::HookContext& hookCtx,                                            \
-        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(               \
+#define DEFINE_HOOK_FUNCTION(R, F, ...)                             \
+    WasmEdge_Result hook_api::WasmFunction##F(                      \
+        void* data_ptr,                                             \
+        const WasmEdge_CallingFrameContext* frameCtx,               \
+        const WasmEdge_Value* in,                                   \
+        WasmEdge_Value* out)                                        \
+    {                                                               \
+        __VA_OPT__(int _stack = 0;)                                 \
+        __VA_OPT__(FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);)           \
+        hook::HookContext* hookCtx =                                \
+            reinterpret_cast<hook::HookContext*>(data_ptr);         \
+        R return_code = hook_api::F(                                \
+            *hookCtx,                                               \
+            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)    \
+                __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));        \
+        if (return_code == RC_ROLLBACK || return_code == RC_ACCEPT) \
+            return WasmEdge_Result_Terminate;                       \
+        out[0] = RET_ASSIGN(R, return_code);                        \
+        return WasmEdge_Result_Success;                             \
+    };                                                              \
+    WasmEdge_ValType hook_api::WasmFunctionParams##F[] = {          \
+        __VA_OPT__(FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__))};       \
+    WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {         \
+        WASM_VAL_TYPE(R, dummy)};                                   \
+    WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =   \
+        WasmEdge_FunctionTypeCreate(                                \
+            WasmFunctionParams##F,                                  \
+            VA_NARGS(NULL __VA_OPT__(, __VA_ARGS__)),               \
+            WasmFunctionResult##F,                                  \
+            1);                                                     \
+    WasmEdge_String hook_api::WasmFunctionName##F =                 \
+        WasmEdge_StringCreateByCString(#F);                         \
+    R hook_api::F(                                                  \
+        hook::HookContext& hookCtx,                                 \
+        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(    \
             COMMA __VA_ARGS__))
 
 #define HOOK_SETUP()                                                 \
-    using enum hook_api::hook_return_code;                           \
     try                                                              \
     {                                                                \
         [[maybe_unused]] ApplyContext& applyCtx = hookCtx.applyCtx;  \
@@ -214,7 +203,7 @@
     host_memory_ptr,                  \
     guest_memory_length)              \
     {                                 \
-        uint64_t bytes_written = 0;   \
+        int64_t bytes_written = 0;    \
         WRITE_WASM_MEMORY(            \
             bytes_written,            \
             guest_dst_ptr,            \
@@ -244,13 +233,7 @@
                                << "Tried to accept/rollback but specified "    \
                                   "memory outside of the wasm instance "       \
                                << "limit when specifying a reason string";     \
-                if (!view.rules().enabled(fix20260929))                        \
-                    return OUT_OF_BOUNDS;                                      \
-                /* fix20260929: terminate as a rollback so the                 \
-                   failure is visible in HookExecution metadata */             \
-                hookCtx.result.exitType = hook_api::ExitType::ROLLBACK;        \
-                hookCtx.result.exitCode = (int64_t)OUT_OF_BOUNDS;              \
-                return RC_ROLLBACK;                                            \
+                return OUT_OF_BOUNDS;                                          \
             }                                                                  \
             /* assembly script and some other languages use utf16 for strings  \
              */                                                                \
@@ -289,7 +272,7 @@
             data_ptr < (data_ptr_in))                                    \
             return INTERNAL_ERROR;                                       \
         if (data_len == 0)                                               \
-            return 0ULL;                                                 \
+            return 0;                                                    \
         if ((write_ptr_in) == 0)                                         \
             return data_as_int64(data_ptr, data_len);                    \
         if (data_len > (write_len_in))                                   \

include/xrpl/hook/hook_api.macro

@@ -1,301 +1,374 @@
-// clang-format off
+// int32_t _g(uint32_t guard_id, uint32_t maxiter);
 HOOK_API_DEFINITION(
-  int32_t, _g, (uint32_t guard_id, uint32_t maxiter),
+  int32_t, _g, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
 HOOK_API_DEFINITION(
-  int64_t, accept, (uint32_t read_ptr, uint32_t read_len, int64_t error_code),
+  int64_t, accept, (uint32_t, uint32_t, int64_t),
   uint256{})
 
+// int64_t rollback(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
 HOOK_API_DEFINITION(
-  int64_t, rollback, (uint32_t read_ptr, uint32_t read_len, int64_t error_code),
+  int64_t, rollback, (uint32_t, uint32_t, int64_t),
   uint256{})
 
+// int64_t util_raddr(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, util_raddr, (uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len),
+  int64_t, util_raddr, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t util_accid(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, util_accid, (uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len),
+  int64_t, util_accid, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t util_verify(uint32_t dread_ptr, uint32_t dread_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
-  int64_t, util_verify, (uint32_t dread_ptr, uint32_t dread_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t kread_ptr, uint32_t kread_len),
+  int64_t, util_verify, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t util_sha512h(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, util_sha512h, (uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len),
+  int64_t, util_sha512h, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t util_keylet(uint32_t write_ptr, uint32_t write_len, uint32_t keylet_type, uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f);
 HOOK_API_DEFINITION(
-  int64_t, util_keylet, (uint32_t write_ptr, uint32_t write_len, uint32_t keylet_type, uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f),
+  int64_t, util_keylet, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t sto_validate(uint32_t tread_ptr, uint32_t tread_len);
 HOOK_API_DEFINITION(
-  int64_t, sto_validate, (uint32_t tread_ptr, uint32_t tread_len),
+  int64_t, sto_validate, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t sto_subfield(uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
 HOOK_API_DEFINITION(
-  int64_t, sto_subfield, (uint32_t read_ptr, uint32_t read_len, uint32_t field_id),
+  int64_t, sto_subfield, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t sto_subarray(uint32_t read_ptr, uint32_t read_len, uint32_t array_id);
 HOOK_API_DEFINITION(
-  int64_t, sto_subarray, (uint32_t read_ptr, uint32_t read_len, uint32_t array_id),
+  int64_t, sto_subarray, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t sto_emplace(uint32_t write_ptr, uint32_t write_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t fread_ptr, uint32_t fread_len, uint32_t field_id);
 HOOK_API_DEFINITION(
-  int64_t, sto_emplace, (uint32_t write_ptr, uint32_t write_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t fread_ptr, uint32_t fread_len, uint32_t field_id),
+  int64_t, sto_emplace, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t sto_erase(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
 HOOK_API_DEFINITION(
-  int64_t, sto_erase, (uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len, uint32_t field_id),
+  int64_t, sto_erase, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t etxn_burden();
 HOOK_API_DEFINITION(
   int64_t, etxn_burden, (),
   uint256{})
 
+// int64_t etxn_details(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
-  int64_t, etxn_details, (uint32_t write_ptr, uint32_t write_len),
+  int64_t, etxn_details, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t etxn_fee_base(uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, etxn_fee_base, (uint32_t read_ptr, uint32_t read_len),
+  int64_t, etxn_fee_base, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t etxn_reserve(uint32_t count);
 HOOK_API_DEFINITION(
-  int64_t, etxn_reserve, (uint32_t count),
+  int64_t, etxn_reserve, (uint32_t),
   uint256{})
 
+// int64_t etxn_generation();
 HOOK_API_DEFINITION(
   int64_t, etxn_generation, (),
   uint256{})
 
+// int64_t etxn_nonce(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
-  int64_t, etxn_nonce, (uint32_t write_ptr, uint32_t write_len),
+  int64_t, etxn_nonce, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t emit(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, emit, (uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len),
+  int64_t, emit, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t float_set(int32_t exponent, int64_t mantissa);
 HOOK_API_DEFINITION(
-  int64_t, float_set, (int32_t exponent, int64_t mantissa),
+  int64_t, float_set, (int32_t, int64_t),
   uint256{})
 
+// int64_t float_multiply(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
-  int64_t, float_multiply, (int64_t float1, int64_t float2),
+  int64_t, float_multiply, (int64_t, int64_t),
   uint256{})
 
+// int64_t float_mulratio(int64_t float1, uint32_t round_up, uint32_t numerator, uint32_t denominator);
 HOOK_API_DEFINITION(
-  int64_t, float_mulratio, (int64_t float1, uint32_t round_up, uint32_t numerator, uint32_t denominator),
+  int64_t, float_mulratio, (int64_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t float_negate(int64_t float1);
 HOOK_API_DEFINITION(
-  int64_t, float_negate, (int64_t float1),
+  int64_t, float_negate, (int64_t),
   uint256{})
 
+// int64_t float_compare(int64_t float1, int64_t float2, uint32_t mode);
 HOOK_API_DEFINITION(
-  int64_t, float_compare, (int64_t float1, int64_t float2, uint32_t mode),
+  int64_t, float_compare, (int64_t, int64_t, uint32_t),
   uint256{})
 
+// int64_t float_sum(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
-  int64_t, float_sum, (int64_t float1, int64_t float2),
+  int64_t, float_sum, (int64_t, int64_t),
   uint256{})
 
+// int64_t float_sto(uint32_t write_ptr, uint32_t write_len, uint32_t cread_ptr, uint32_t cread_len, uint32_t iread_ptr, uint32_t iread_len, int64_t float1, uint32_t field_code);
 HOOK_API_DEFINITION(
-  int64_t, float_sto, (uint32_t write_ptr, uint32_t write_len, uint32_t cread_ptr, uint32_t cread_len, uint32_t iread_ptr, uint32_t iread_len, int64_t float1, uint32_t field_code),
+  int64_t, float_sto, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int64_t, uint32_t),
   uint256{})
 
+// int64_t float_sto_set(uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, float_sto_set, (uint32_t read_ptr, uint32_t read_len),
+  int64_t, float_sto_set, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t float_invert(int64_t float1);
 HOOK_API_DEFINITION(
-  int64_t, float_invert, (int64_t float1),
+  int64_t, float_invert, (int64_t),
   uint256{})
 
+// int64_t float_divide(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
-  int64_t, float_divide, (int64_t float1, int64_t float2),
+  int64_t, float_divide, (int64_t, int64_t),
   uint256{})
 
+// int64_t float_one();
 HOOK_API_DEFINITION(
   int64_t, float_one, (),
   uint256{})
 
+// int64_t float_mantissa(int64_t float1);
 HOOK_API_DEFINITION(
-  int64_t, float_mantissa, (int64_t float1),
+  int64_t, float_mantissa, (int64_t),
   uint256{})
 
+// int64_t float_sign(int64_t float1);
 HOOK_API_DEFINITION(
-  int64_t, float_sign, (int64_t float1),
+  int64_t, float_sign, (int64_t),
   uint256{})
 
+// int64_t float_int(int64_t float1, uint32_t decimal_places, uint32_t abs);
 HOOK_API_DEFINITION(
-  int64_t, float_int, (int64_t float1, uint32_t decimal_places, uint32_t abs),
+  int64_t, float_int, (int64_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t float_log(int64_t float1);
 HOOK_API_DEFINITION(
-  int64_t, float_log, (int64_t float1),
+  int64_t, float_log, (int64_t),
   uint256{})
 
+// int64_t float_root(int64_t float1, uint32_t n);
 HOOK_API_DEFINITION(
-  int64_t, float_root, (int64_t float1, uint32_t n),
+  int64_t, float_root, (int64_t, uint32_t),
   uint256{})
 
+// int64_t fee_base();
 HOOK_API_DEFINITION(
   int64_t, fee_base, (),
   uint256{})
 
+// int64_t ledger_seq();
 HOOK_API_DEFINITION(
   int64_t, ledger_seq, (),
   uint256{})
 
+// int64_t ledger_last_time();
 HOOK_API_DEFINITION(
   int64_t, ledger_last_time, (),
   uint256{})
 
+// int64_t ledger_last_hash(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
-  int64_t, ledger_last_hash, (uint32_t write_ptr, uint32_t write_len),
+  int64_t, ledger_last_hash, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t ledger_nonce(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
-  int64_t, ledger_nonce, (uint32_t write_ptr, uint32_t write_len),
+  int64_t, ledger_nonce, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t ledger_keylet(uint32_t write_ptr, uint32_t write_len, uint32_t lread_ptr, uint32_t lread_len, uint32_t hread_ptr, uint32_t hread_len);
 HOOK_API_DEFINITION(
-  int64_t, ledger_keylet, (uint32_t write_ptr, uint32_t write_len, uint32_t lread_ptr, uint32_t lread_len, uint32_t hread_ptr, uint32_t hread_len),
+  int64_t, ledger_keylet, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t hook_account(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
-  int64_t, hook_account, (uint32_t write_ptr, uint32_t write_len),
+  int64_t, hook_account, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t hook_hash(uint32_t write_ptr, uint32_t write_len, int32_t hook_no);
 HOOK_API_DEFINITION(
-  int64_t, hook_hash, (uint32_t write_ptr, uint32_t write_len, int32_t hook_no),
+  int64_t, hook_hash, (uint32_t, uint32_t, int32_t),
   uint256{})
 
+// int64_t hook_param_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t hread_ptr, uint32_t hread_len);
 HOOK_API_DEFINITION(
-  int64_t, hook_param_set, (uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t hread_ptr, uint32_t hread_len),
+  int64_t, hook_param_set, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t hook_param(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, hook_param, (uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len),
+  int64_t, hook_param, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t hook_again();
 HOOK_API_DEFINITION(
   int64_t, hook_again, (),
   uint256{})
 
+// int64_t hook_skip(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
 HOOK_API_DEFINITION(
-  int64_t, hook_skip, (uint32_t read_ptr, uint32_t read_len, uint32_t flags),
+  int64_t, hook_skip, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t hook_pos();
 HOOK_API_DEFINITION(
   int64_t, hook_pos, (),
   uint256{})
 
+// int64_t slot(uint32_t write_ptr, uint32_t write_len, uint32_t slot);
 HOOK_API_DEFINITION(
-  int64_t, slot, (uint32_t write_ptr, uint32_t write_len, uint32_t slot),
+  int64_t, slot, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t slot_clear(uint32_t slot);
 HOOK_API_DEFINITION(
-  int64_t, slot_clear, (uint32_t slot),
+  int64_t, slot_clear, (uint32_t),
   uint256{})
 
+// int64_t slot_count(uint32_t slot);
 HOOK_API_DEFINITION(
-  int64_t, slot_count, (uint32_t slot),
+  int64_t, slot_count, (uint32_t),
   uint256{})
 
+// int64_t slot_set(uint32_t read_ptr, uint32_t read_len, uint32_t slot);
 HOOK_API_DEFINITION(
-  int64_t, slot_set, (uint32_t read_ptr, uint32_t read_len, uint32_t slot),
+  int64_t, slot_set, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t slot_size(uint32_t slot);
 HOOK_API_DEFINITION(
-  int64_t, slot_size, (uint32_t slot),
+  int64_t, slot_size, (uint32_t),
   uint256{})
 
+// int64_t slot_subarray(uint32_t parent_slot, uint32_t array_id, uint32_t new_slot);
 HOOK_API_DEFINITION(
-  int64_t, slot_subarray, (uint32_t parent_slot, uint32_t array_id, uint32_t new_slot),
+  int64_t, slot_subarray, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t slot_subfield(uint32_t parent_slot, uint32_t field_id, uint32_t new_slot);
 HOOK_API_DEFINITION(
-  int64_t, slot_subfield, (uint32_t parent_slot, uint32_t field_id, uint32_t new_slot),
+  int64_t, slot_subfield, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t slot_type(uint32_t slot_no, uint32_t flags);
 HOOK_API_DEFINITION(
-  int64_t, slot_type, (uint32_t slot_no, uint32_t flags),
+  int64_t, slot_type, (uint32_t, uint32_t),
   uint256{})
 
+// int64_t slot_float(uint32_t slot_no);
 HOOK_API_DEFINITION(
-  int64_t, slot_float, (uint32_t slot_no),
+  int64_t, slot_float, (uint32_t),
   uint256{})
 
+// int64_t state_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
-  int64_t, state_set, (uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len),
+  int64_t, state_set, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t state_foreign_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len);
 HOOK_API_DEFINITION(
-  int64_t, state_foreign_set, (uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len),
+  int64_t, state_foreign_set, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t state(uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
-  int64_t, state, (uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len),
+  int64_t, state, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t state_foreign(uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len);
 HOOK_API_DEFINITION(
-  int64_t, state_foreign, (uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len),
+  int64_t, state_foreign, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t trace(uint32_t mread_ptr, uint32_t mread_len, uint32_t dread_ptr, uint32_t dread_len, uint32_t as_hex);
 HOOK_API_DEFINITION(
-  int64_t, trace, (uint32_t mread_ptr, uint32_t mread_len, uint32_t dread_ptr, uint32_t dread_len, uint32_t as_hex),
+  int64_t, trace, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t trace_num(uint32_t read_ptr, uint32_t read_len, int64_t number);
 HOOK_API_DEFINITION(
-  int64_t, trace_num, (uint32_t read_ptr, uint32_t read_len, int64_t number),
+  int64_t, trace_num, (uint32_t, uint32_t, int64_t),
   uint256{})
 
+// int64_t trace_float(uint32_t read_ptr, uint32_t read_len, int64_t float1);
 HOOK_API_DEFINITION(
-  int64_t, trace_float, (uint32_t read_ptr, uint32_t read_len, int64_t float1),
+  int64_t, trace_float, (uint32_t, uint32_t, int64_t),
   uint256{})
 
+// int64_t otxn_burden();
 HOOK_API_DEFINITION(
   int64_t, otxn_burden, (),
   uint256{})
 
+// int64_t otxn_field(uint32_t write_ptr, uint32_t write_len, uint32_t field_id);
 HOOK_API_DEFINITION(
-  int64_t, otxn_field, (uint32_t write_ptr, uint32_t write_len, uint32_t field_id),
+  int64_t, otxn_field, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t otxn_generation();
 HOOK_API_DEFINITION(
   int64_t, otxn_generation, (),
   uint256{})
 
+// int64_t otxn_id(uint32_t write_ptr, uint32_t write_len, uint32_t flags);
 HOOK_API_DEFINITION(
-  int64_t, otxn_id, (uint32_t write_ptr, uint32_t write_len, uint32_t flags),
+  int64_t, otxn_id, (uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t otxn_type();
 HOOK_API_DEFINITION(
   int64_t, otxn_type, (),
   uint256{})
 
+// int64_t otxn_slot(uint32_t slot_no);
 HOOK_API_DEFINITION(
-  int64_t, otxn_slot, (uint32_t slot_no),
+  int64_t, otxn_slot, (uint32_t),
   uint256{})
 
+// int64_t otxn_param(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, otxn_param, (uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len),
+  int64_t, otxn_param, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
 
+// int64_t meta_slot(uint32_t slot_no);
 HOOK_API_DEFINITION(
-  int64_t, meta_slot, (uint32_t slot_no),
+  int64_t, meta_slot, (uint32_t),
   uint256{})
 
+// int64_t xpop_slot(uint32_t slot_no_tx, uint32_t slot_no_meta);
 HOOK_API_DEFINITION(
-  int64_t, xpop_slot, (uint32_t slot_no_tx, uint32_t slot_no_meta),
+  int64_t, xpop_slot, (uint32_t, uint32_t),
   featureHooksUpdate1)
 
+// int64_t prepare(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
-  int64_t, prepare, (uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len),
+  int64_t, prepare, (uint32_t, uint32_t, uint32_t, uint32_t),
   featureHooksUpdate2)
-// clang-format on

include/xrpl/json/json_reader.h

@@ -215,7 +215,7 @@ Reader::parse(Value& root, BufferSequence const& bs)
     std::string s;
     s.reserve(buffer_size(bs));
     for (auto const& b : bs)
-        s.append(static_cast<char const*>(b.data()), buffer_size(b));
+        s.append(buffer_cast<char const*>(b), buffer_size(b));
     return parse(s, root);
 }
 

include/xrpl/protocol/Feature.h

@@ -33,39 +33,35 @@
  *
  * Steps required to add new features to the code:
  *
- * 1) Add the appropriate XRPL_FEATURE or XRPL_FIX macro definition for the
- *    feature to features.macro with the feature's name, `Supported::no`, and
- *    `VoteBehavior::DefaultNo`.
- *
- * 2) Use the generated variable name as the parameter to `view.rules.enabled()`
- *    to control flow into new code that this feature limits. (featureName or
- *    fixName)
- *
- * 3) If the feature development is COMPLETE, and the feature is ready to be
- *    SUPPORTED, change the macro parameter in features.macro to Supported::yes.
- *
- * 4) In general, any newly supported amendments (`Supported::yes`) should have
- *    a `VoteBehavior::DefaultNo` indefinitely so that external governance can
- *    make the decision on when to activate it. High priority bug fixes can be
- *    an exception to this rule. In such cases, ensure the fix has been
- *    clearly communicated to the community using appropriate channels,
- *    then change the macro parameter in features.macro to
- *    `VoteBehavior::DefaultYes`. The communication process is beyond
- *    the scope of these instructions.
- *
+ * 1) In this file, increment `numFeatures` and add a uint256 declaration
+ *    for the feature at the bottom
+ * 2) Add a uint256 definition for the feature to the corresponding source
+ *    file (Feature.cpp). Use `registerFeature` to create the feature with
+ *    the feature's name, `Supported::no`, and `VoteBehavior::DefaultNo`. This
+ *    should be the only place the feature's name appears in code as a string.
+ * 3) Use the uint256 as the parameter to `view.rules.enabled()` to
+ *    control flow into new code that this feature limits.
+ * 4) If the feature development is COMPLETE, and the feature is ready to be
+ *    SUPPORTED, change the `registerFeature` parameter to Supported::yes.
+ * 5) When the feature is ready to be ENABLED, change the `registerFeature`
+ *    parameter to `VoteBehavior::DefaultYes`.
+ * In general, any newly supported amendments (`Supported::yes`) should have
+ * a `VoteBehavior::DefaultNo` for at least one full release cycle. High
+ * priority bug fixes can be an exception to this rule of thumb.
  *
  * When a feature has been enabled for several years, the conditional code
  * may be removed, and the feature "retired". To retire a feature:
- *
- * 1) MOVE the macro definition in features.macro to the "retired features"
- *    section at the end of the file, and change the macro to XRPL_RETIRE.
- *
+ * 1) Remove the uint256 declaration from this file.
+ * 2) MOVE the uint256 definition in Feature.cpp to the "retired features"
+ *    section at the end of the file.
+ * 3) CHANGE the name of the variable to start with "retired".
+ * 4) CHANGE the parameters of the `registerFeature` call to `Supported::yes`
+ *    and `VoteBehavior::DefaultNo`.
  * The feature must remain registered and supported indefinitely because it
- * may exist in the Amendments object on ledger. There is no need to vote
- * for it because there's nothing to vote for. If the feature definition is
- * removed completely from the code, any instances running that code will get
- * amendment blocked. Removing the feature from the ledger is beyond the scope
- * of these instructions.
+ * still exists in the ledger, but there is no need to vote for it because
+ * there's nothing to vote for. If it is removed completely from the code, any
+ * instances running that code will get amendment blocked. Removing the
+ * feature from the ledger is beyond the scope of these instructions.
  *
  */
 
@@ -80,32 +76,11 @@ allAmendments();
 
 namespace detail {
 
-#pragma push_macro("XRPL_FEATURE")
-#undef XRPL_FEATURE
-#pragma push_macro("XRPL_FIX")
-#undef XRPL_FIX
-#pragma push_macro("XRPL_RETIRE")
-#undef XRPL_RETIRE
-
-#define XRPL_FEATURE(name, supported, vote) +1
-#define XRPL_FIX(name, supported, vote) +1
-#define XRPL_RETIRE(name) +1
-
 // This value SHOULD be equal to the number of amendments registered in
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures =
-    (0 +
-#include <xrpl/protocol/detail/features.macro>
-    );
-
-#undef XRPL_RETIRE
-#pragma pop_macro("XRPL_RETIRE")
-#undef XRPL_FIX
-#pragma pop_macro("XRPL_FIX")
-#undef XRPL_FEATURE
-#pragma pop_macro("XRPL_FEATURE")
+static constexpr std::size_t numFeatures = 113;
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated
@@ -345,17 +320,12 @@ foreachFeature(FeatureBitset bs, F&& f)
 #undef XRPL_FEATURE
 #pragma push_macro("XRPL_FIX")
 #undef XRPL_FIX
-#pragma push_macro("XRPL_RETIRE")
-#undef XRPL_RETIRE
 
 #define XRPL_FEATURE(name, supported, vote) extern uint256 const feature##name;
 #define XRPL_FIX(name, supported, vote) extern uint256 const fix##name;
-#define XRPL_RETIRE(name)
 
 #include <xrpl/protocol/detail/features.macro>
 
-#undef XRPL_RETIRE
-#pragma pop_macro("XRPL_RETIRE")
 #undef XRPL_FIX
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE

include/xrpl/protocol/Import.h

@@ -24,7 +24,6 @@
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/StringUtilities.h>
 #include <xrpl/basics/base64.h>
-#include <xrpl/basics/chrono.h>
 #include <xrpl/json/json_reader.h>
 #include <charconv>
 
@@ -119,9 +118,8 @@ syntaxCheckProof(
         {
             if (!proof["hash"].isString() ||
                 proof["hash"].asString().size() != 64 ||
-                !isHex(proof["hash"].asString()) || !proof["key"].isString() ||
+                !proof["key"].isString() ||
                 proof["key"].asString().size() != 64 ||
-                !isHex(proof["key"].asString()) ||
                 !proof["children"].isObject())
             {
                 JLOG(j.warn()) << "XPOP.transaction.proof tree node has wrong "
@@ -134,11 +132,7 @@ syntaxCheckProof(
 
         for (const auto& branch : proof.getMemberNames())
         {
-            // Upper case only: the txroot computation only looks up "0"-"F",
-            // so any other key would be silently ignored.
-            if (branch.size() != 1 ||
-                branch.find_first_not_of("0123456789ABCDEF") !=
-                    std::string::npos)
+            if (branch.size() != 1 || !isHex(branch))
             {
                 JLOG(j.warn())
                     << "XPOP.transaction.proof child node was not 0-F "
@@ -149,9 +143,9 @@ syntaxCheckProof(
             const auto& node = proof[branch];
             if (!node.isObject() || !node["hash"].isString() ||
                 node["hash"].asString().size() != 64 ||
-                !isHex(node["hash"].asString()) || !node["key"].isString() ||
+                !node["key"].isString() ||
                 node["key"].asString().size() != 64 ||
-                !isHex(node["key"].asString()) || !node["children"].isObject())
+                !node["children"].isObject())
             {
                 JLOG(j.warn())
                     << "XPOP.transaction.proof tree node has wrong format";
@@ -471,45 +465,6 @@ getVLInfo(Json::Value const& xpop, beast::Journal const& j)
     return {{sequence, m->masterKey}};
 }
 
-// <effective, expiration> of the unl blob, effective defaulting to the epoch
-inline std::optional<std::pair<NetClock::time_point, NetClock::time_point>>
-getVLWindow(Json::Value const& xpop, beast::Journal const& j)
-{
-    auto const data =
-        base64_decode(xpop[jss::validation][jss::unl][jss::blob].asString());
-    Json::Reader r;
-    Json::Value parsed;
-    if (!r.parse(data, parsed) || !parsed.isObject())
-    {
-        JLOG(j.warn()) << "Import: unl blob was not a json object (after "
-                          "base64 decoding)";
-        return {};
-    }
-
-    // const, so that operator[] does not insert missing members
-    Json::Value const& list = parsed;
-    auto const time = [&list](Json::StaticString const& field)
-        -> std::optional<NetClock::time_point> {
-        auto const& v = list[field];
-        if (!v.isInt() || v.asInt() < 0)
-            return {};
-        return NetClock::time_point{NetClock::duration{v.asUInt()}};
-    };
-
-    auto const validUntil = time(jss::expiration);
-    auto const validFrom = list.isMember(jss::effective)
-        ? time(jss::effective)
-        : std::optional<NetClock::time_point>{NetClock::time_point{}};
-    if (!validUntil || !validFrom)
-    {
-        JLOG(j.warn()) << "Import: unl blob json (after base64 decoding) "
-                          "had missing or invalid effective/expiration";
-        return {};
-    }
-
-    return {{*validFrom, *validUntil}};
-}
-
 }  // namespace ripple
 
 #endif

include/xrpl/protocol/Indexes.h

@@ -372,10 +372,6 @@ permissionedDomain(AccountID const& account, std::uint32_t seq) noexcept;
 
 Keylet
 permissionedDomain(uint256 const& domainID) noexcept;
-
-Keylet
-manifest(PublicKey const& pk) noexcept;
-
 }  // namespace keylet
 
 // Everything below is deprecated and should be removed in favor of keylets:

include/xrpl/protocol/TER.h

@@ -69,7 +69,6 @@ enum TELcodes : TERUnderlyingType {
     telIMPORT_VL_KEY_NOT_RECOGNISED,
     telCAN_NOT_QUEUE_IMPORT,
     telENV_RPC_FAILED,
-    telMANIFEST_FEE_MISMATCH,
 };
 
 //------------------------------------------------------------------------------
@@ -138,7 +137,6 @@ enum TEMcodes : TERUnderlyingType {
     temXCHAIN_BRIDGE_NONDOOR_OWNER,
     temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT,
     temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT,
-    temXCHAIN_TOO_MANY_ATTESTATIONS,  // RESERVED - not used
 
     temHOOK_DATA_TOO_LARGE,
     temEMPTY_DID,
@@ -195,8 +193,6 @@ enum TEFcodes : TERUnderlyingType {
     tefNONDIR_EMIT,
     tefIMPORT_BLACKHOLED,
     tefINVALID_LEDGER_FIX_TYPE,
-    tefPAST_MANIFEST_SEQ,
-    tefREVOKED_MANIFEST,
 };
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/TxFlags.h

@@ -132,7 +132,7 @@ constexpr std::uint32_t tfTrustSetMask =
       tfClearFreeze | tfSetDeepFreeze | tfClearDeepFreeze);
 
 // EnableAmendment flags:
-enum EnableAmendmentFlags : uint32_t {
+enum EnableAmendmentFlags : std::uint32_t {
     tfGotMajority = 0x00010000,
     tfLostMajority = 0x00020000,
     tfTestSuite = 0x80000000,

include/xrpl/protocol/detail/features.macro

@@ -23,9 +23,6 @@
 #if !defined(XRPL_FIX)
 #error "undefined macro: XRPL_FIX"
 #endif
-#if !defined(XRPL_RETIRE)
-#error "undefined macro: XRPL_RETIRE"
-#endif
 
 // clang-format off
 
@@ -34,22 +31,11 @@
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
 
-XRPL_FIX    (20261005,                   Supported::yes, VoteBehavior::DefaultYes)
-XRPL_FEATURE(EscrowDestinationCancel,    Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (20260929,                   Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FEATURE(HookOnV2_1,                 Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FEATURE(OnChainManifests,           Supported::yes,  VoteBehavior::DefaultNo)
-XRPL_FIX    (HookMap,                    Supported::yes, VoteBehavior::DefaultYes)
-XRPL_FIX    (GuardDepth32,               Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FEATURE(NamedHooks,                 Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FEATURE(IOURewardClaim,             Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (IOULockedBalanceInvariant,  Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (ImportIssuer,               Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(HookAPISerializedType240,   Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionedDomains,        Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(DynamicNFT,                 Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(Credentials,                Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(AMMClawback,                Supported::no,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(AMMClawback,                Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV1,                 Supported::no,  VoteBehavior::DefaultNo)
 // InvariantsV1_1 will be changes to Supported::yes when all the
 // invariants expected to be included under it are complete.
@@ -66,19 +52,18 @@ XRPL_FIX    (FillOrKill,                 Supported::yes, VoteBehavior::DefaultYe
 XRPL_FEATURE(DID,                        Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (DisallowIncomingV1,         Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(XChainBridge,               Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(AMM,                        Supported::no,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(AMM,                        Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (ReducedOffersV1,            Supported::yes, VoteBehavior::DefaultYes)
-XRPL_FEATURE(HooksUpdate2,               Supported::yes, VoteBehavior::DefaultNo)
-// replaced to HookOnV2_1
-XRPL_FEATURE(HookOnV2,                   Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FIX    (HookAPI20251128,            Supported::yes, VoteBehavior::DefaultYes)
-XRPL_FIX    (CronStacking,               Supported::yes, VoteBehavior::DefaultYes)
-XRPL_FEATURE(ExtendedHookState,          Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultYes)
-XRPL_FEATURE(Cron,                       Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FEATURE(IOUIssuerWeakTSH,           Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo)
-XRPL_FIX    (ProvisionalDoubleThreading, Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FEATURE(HooksUpdate2,               Supported::yes, VoteBehavior::DefaultNo);
+XRPL_FEATURE(HookOnV2,                   Supported::yes, VoteBehavior::DefaultNo);
+XRPL_FIX    (HookAPI20251128,            Supported::yes, VoteBehavior::DefaultYes);
+XRPL_FIX    (CronStacking,               Supported::yes, VoteBehavior::DefaultYes);
+XRPL_FEATURE(ExtendedHookState,          Supported::yes, VoteBehavior::DefaultNo);
+XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultYes);
+XRPL_FEATURE(Cron,                       Supported::yes, VoteBehavior::DefaultNo);
+XRPL_FEATURE(IOUIssuerWeakTSH,           Supported::yes, VoteBehavior::DefaultNo);
+XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo);
+XRPL_FIX    (ProvisionalDoubleThreading, Supported::yes, VoteBehavior::DefaultYes);
 XRPL_FEATURE(Clawback,                   Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (RewardClaimFlags,           Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(HookCanEmit,                Supported::yes, VoteBehavior::DefaultNo)
@@ -94,6 +79,8 @@ XRPL_FIX    (240819,                     Supported::yes, VoteBehavior::DefaultYe
 XRPL_FIX    (NSDelete,                   Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(ZeroB2M,                    Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(Remit,                      Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (XahauV2,                    Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (XahauV1,                    Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(HooksUpdate1,               Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(XahauGenesis,               Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(Import,                     Supported::yes, VoteBehavior::DefaultYes)
@@ -160,26 +147,4 @@ XRPL_FIX    (NFTokenDirV1,          Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(NonFungibleTokensV1,   Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(CryptoConditionsSuite, Supported::yes, VoteBehavior::Obsolete)
 
-// The following amendments have been active for at least two years. Their
-// pre-amendment code has been removed and the identifiers are deprecated.
-// All known amendments and amendments that may appear in a validated
-// ledger must be registered either here or above with the "active" amendments
-XRPL_RETIRE(fixXahauV2)
-XRPL_RETIRE(fixXahauV1)
-XRPL_RETIRE(MultiSign)
-XRPL_RETIRE(TrustSetAuth)
-XRPL_RETIRE(FeeEscalation)
-XRPL_RETIRE(PayChan)
-XRPL_RETIRE(CryptoConditions)
-XRPL_RETIRE(TickSize)
-XRPL_RETIRE(fix1368)
-XRPL_RETIRE(Escrow)
-XRPL_RETIRE(fix1373)
-XRPL_RETIRE(EnforceInvariants)
-XRPL_RETIRE(SortedDirectories)
-XRPL_RETIRE(fix1201)
-XRPL_RETIRE(fix1512)
-XRPL_RETIRE(fix1523)
-XRPL_RETIRE(fix1528)
-
 // clang-format on

include/xrpl/protocol/detail/ledger_entries.macro

@@ -22,14 +22,14 @@
 #endif
 
 #ifndef LEDGER_ENTRY_DUPLICATE
-// The LEDGER_ENTRY_EXPAND macro is needed for Windows
+// The EXPAND macro is needed for Windows
 // https://stackoverflow.com/questions/5134523/msvc-doesnt-expand-va-args-correctly
-#define LEDGER_ENTRY_EXPAND(x) x
+#define EXPAND(x) x
 
 // The `LEDGER_ENTRY_DUPLICATE macro is needed to avoid JSS conflicts
 // Since some transactions and ledger entries have the same name (like `DepositPreauth`)
 // The compiler won't accept two instances of `JSS(DepositPreauth)`
-#define LEDGER_ENTRY_DUPLICATE(...) LEDGER_ENTRY_EXPAND(LEDGER_ENTRY(__VA_ARGS__))
+#define LEDGER_ENTRY_DUPLICATE(...) EXPAND(LEDGER_ENTRY(__VA_ARGS__))
 #endif
 
 /**
@@ -93,7 +93,7 @@ LEDGER_ENTRY(ltCHECK, 0x0043, Check, check, ({
 */
 LEDGER_ENTRY(ltHOOK_DEFINITION, 'D', HookDefinition, hook_definition, ({
     {sfHookHash,             soeREQUIRED},
-    {sfHookOn,               soeOPTIONAL},
+    {sfHookOn,               soeREQUIRED},
     {sfHookOnIncoming,       soeOPTIONAL},
     {sfHookOnOutgoing,       soeOPTIONAL},
     {sfHookCanEmit,          soeOPTIONAL},
@@ -262,7 +262,6 @@ LEDGER_ENTRY(ltACCOUNT_ROOT, 0x0061, AccountRoot, account, ({
     {sfHookStateScale,       soeOPTIONAL},
     {sfCron,                 soeOPTIONAL},
     {sfAMMID,                soeOPTIONAL},
-    {sfManifestID,           soeOPTIONAL},
 }))
 
 /** A ledger object which contains a list of object identifiers.
@@ -397,8 +396,6 @@ LEDGER_ENTRY(ltRIPPLE_STATE, 0x0072, RippleState, state, ({
     {sfHighQualityOut,       soeOPTIONAL},
     {sfLockedBalance,        soeOPTIONAL},
     {sfLockCount,            soeOPTIONAL},
-    {sfHighReward,           soeOPTIONAL},
-    {sfLowReward,            soeOPTIONAL},
 }))
 
 /** The ledger object which lists the network's fee settings.
@@ -593,26 +590,6 @@ LEDGER_ENTRY(ltDID, 0x008D, DID, did, ({
     {sfPreviousTxnLgrSeq,    soeREQUIRED},
 }))
 
-LEDGER_ENTRY(ltMANIFEST, 0x004D, Manifest, manifest_entry, ({
-    {sfAccount,             soeREQUIRED},
-    {sfPublicKey,           soeREQUIRED},
-    {sfSigningPubKey,       soeOPTIONAL}, /* may be absent if the master is revoked */
-    {sfSequence,            soeREQUIRED},
-    /* sfVersion defaults to 0 and is omitted from the signed payload when
-       absent. Storing it unconditionally would change the bytes and break
-       signature verification when the manifest is reconstructed. */
-    {sfVersion,             soeOPTIONAL},
-    {sfDomain,              soeOPTIONAL},
-    /* The signatures are mirrored so the object is a lossless copy of the
-       manifest and can be independently verified, and re-served to peers,
-       by any node reading it (see ManifestCache::applyLedger). */
-    {sfMasterSignature,     soeREQUIRED},
-    {sfSignature,           soeOPTIONAL}, /* absent if the master is revoked */
-    {sfManifestID,          soeOPTIONAL}, /* pointer to the identical other copy on the other key */
-    {sfPreviousTxnID,       soeREQUIRED},
-    {sfPreviousTxnLgrSeq,   soeREQUIRED},
-}))
-
-#undef LEDGER_ENTRY_EXPAND
+#undef EXPAND
 #undef LEDGER_ENTRY_DUPLICATE
 

include/xrpl/protocol/detail/sfields.macro

@@ -210,7 +210,6 @@ TYPED_SFIELD(sfOfferID,                  UINT256,   34)
 TYPED_SFIELD(sfEscrowID,                 UINT256,   35)
 TYPED_SFIELD(sfURITokenID,               UINT256,   36)
 TYPED_SFIELD(sfDomainID,                 UINT256,   37)
-TYPED_SFIELD(sfManifestID,               UINT256,   91)
 TYPED_SFIELD(sfHookOnOutgoing,           UINT256,   93)
 TYPED_SFIELD(sfHookOnIncoming,           UINT256,   94)
 TYPED_SFIELD(sfCron,                     UINT256,   95)
@@ -258,7 +257,6 @@ TYPED_SFIELD(sfPrice,                    AMOUNT,    28)
 TYPED_SFIELD(sfSignatureReward,          AMOUNT,    29)
 TYPED_SFIELD(sfMinAccountCreateAmount,   AMOUNT,    30)
 TYPED_SFIELD(sfLPTokenBalance,           AMOUNT,    31)
-TYPED_SFIELD(sfTrustLineRewardAccumulator,AMOUNT,   99)
 
 // variable length (common)
 TYPED_SFIELD(sfPublicKey,                VL,         1)
@@ -294,7 +292,6 @@ TYPED_SFIELD(sfAssetClass,               VL,        29)
 TYPED_SFIELD(sfProvider,                 VL,        30)
 TYPED_SFIELD(sfMPTokenMetadata,          VL,        31)
 TYPED_SFIELD(sfCredentialType,           VL,        32)
-TYPED_SFIELD(sfHookName,                 VL,        97)
 TYPED_SFIELD(sfRemarkValue,              VL,        98)
 TYPED_SFIELD(sfRemarkName,               VL,        99)
 
@@ -343,7 +340,6 @@ TYPED_SFIELD(sfLockingChainIssue,        ISSUE,      1)
 TYPED_SFIELD(sfIssuingChainIssue,        ISSUE,      2)
 TYPED_SFIELD(sfAsset,                    ISSUE,      3)
 TYPED_SFIELD(sfAsset2,                   ISSUE,      4)
-TYPED_SFIELD(sfClaimCurrency,            ISSUE,      5)
 
 // bridge
 TYPED_SFIELD(sfXChainBridge,             XCHAIN_BRIDGE, 1)
@@ -371,7 +367,7 @@ UNTYPED_SFIELD(sfMajority,               OBJECT,    18)
 UNTYPED_SFIELD(sfDisabledValidator,      OBJECT,    19)
 UNTYPED_SFIELD(sfEmittedTxn,             OBJECT,    20)
 UNTYPED_SFIELD(sfHookExecution,          OBJECT,    21)
-                                                 // 22 unused
+UNTYPED_SFIELD(sfHookDefinition,         OBJECT,    22)
 UNTYPED_SFIELD(sfHookParameter,          OBJECT,    23)
 UNTYPED_SFIELD(sfHookGrant,              OBJECT,    24)
 UNTYPED_SFIELD(sfVoteEntry,              OBJECT,    25)
@@ -383,7 +379,6 @@ UNTYPED_SFIELD(sfXChainClaimAttestationCollectionElement, OBJECT, 30)
 UNTYPED_SFIELD(sfXChainCreateAccountAttestationCollectionElement, OBJECT, 31)
 UNTYPED_SFIELD(sfPriceData,              OBJECT,    32)
 UNTYPED_SFIELD(sfCredential,             OBJECT,    33)
-UNTYPED_SFIELD(sfManifest,               OBJECT,    90)
 UNTYPED_SFIELD(sfAmountEntry,            OBJECT,    91)
 UNTYPED_SFIELD(sfMintURIToken,           OBJECT,    92)
 UNTYPED_SFIELD(sfHookEmission,           OBJECT,    93)
@@ -391,8 +386,6 @@ UNTYPED_SFIELD(sfImportVLKey,            OBJECT,    94)
 UNTYPED_SFIELD(sfActiveValidator,        OBJECT,    95)
 UNTYPED_SFIELD(sfGenesisMint,            OBJECT,    96)
 UNTYPED_SFIELD(sfRemark,                 OBJECT,    97)
-UNTYPED_SFIELD(sfHighReward,             OBJECT,    98)
-UNTYPED_SFIELD(sfLowReward,              OBJECT,    99)
 
 // array of objects (common)
 // ARRAY/1 is reserved for end of array

include/xrpl/protocol/detail/transactions.macro

@@ -500,12 +500,6 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 72, PermissionedDomainDelete, ({
     {sfDomainID, soeREQUIRED},
 }))
 
-/* sfAccount is supplied by TxFormats::commonFields; listing it here as well
-   makes the SOTemplate reject the format at construction. */
-TRANSACTION(ttMANIFEST_SET, 91, SetManifest, ({
-    {sfManifest, soeREQUIRED},
-}))
-
 /* A pseudo-txn alarm signal for invoking a hook, emitted by validators after alarm set conditions are met */
 TRANSACTION(ttCRON, 92, Cron, ({
     {sfOwner, soeREQUIRED},
@@ -556,7 +550,6 @@ TRANSACTION(ttIMPORT, 97, Import, ({
   * from a specified hook */
 TRANSACTION(ttCLAIM_REWARD, 98, ClaimReward, ({
     {sfIssuer, soeOPTIONAL},
-    {sfClaimCurrency, soeOPTIONAL},
 }))
 
 /** This transaction invokes a hook, providing arbitrary data. Essentially as a 0 drop payment. **/

include/xrpl/protocol/jss.h

@@ -47,7 +47,6 @@ JSS(AL_hit_rate);    // out: GetCounts
 JSS(AcceptedCredentials);  // out: AccountObjects
 JSS(Account);        // in: TransactionSign; field.
 JSS(AMMID);          // field
-JSS(API);            // out: RPC server_definitions (HOOK)
 JSS(Amount);         // in: TransactionSign; field.
 JSS(Authorize);      // field
 JSS(Amount2);        // in/out: AMM IOU/XRP pool, deposit, withdraw amount
@@ -69,9 +68,6 @@ JSS(Destination);      // in: TransactionSign; field.
 JSS(EPrice);           // in: AMM Deposit option
 JSS(Fee);              // in/out: TransactionSign; field.
 JSS(FIELDS);           // out: RPC server_definitions
-JSS(HOOK);             // out: RPC server_definitions
-JSS(KEYLET_TYPES);     // out: RPC server_definitions (HOOK)
-JSS(RETURN_CODES);     // out: RPC server_definitions (HOOK)
 JSS(Flags);            // in/out: TransactionSign; field.
 JSS(GenesisMints);
 JSS(GovernanceMarks);
@@ -80,7 +76,6 @@ JSS(Holder);              // field.
 JSS(HookApiVersion);      // field
 JSS(HookCanEmit);         // field
 JSS(HookHash);            // field
-JSS(HookName);            // field
 JSS(HookNamespace);       // field
 JSS(HookOn);              // field
 JSS(HookOnIncoming);      // field
@@ -296,9 +291,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
@@ -356,7 +349,6 @@ JSS(hash_mismatches);       // out: catalogue
 JSS(have_header);           // out: InboundLedger
 JSS(have_state);            // out: InboundLedger
 JSS(have_transactions);     // out: InboundLedger
-JSS(hooks);                 // in/out: AccountInfo
 JSS(high);                  // out: BookChanges
 JSS(highest_sequence);      // out: AccountInfo
 JSS(highest_ticket);        // out: AccountInfo

include/xrpl/server/Server.h

@@ -24,8 +24,7 @@
 #include <xrpl/beast/utility/PropertyStream.h>
 #include <xrpl/server/Port.h>
 #include <xrpl/server/detail/ServerImpl.h>
-
-#include <boost/asio/io_context.hpp>
+#include <boost/asio/io_service.hpp>
 
 namespace ripple {
 
@@ -34,10 +33,10 @@ template <class Handler>
 std::unique_ptr<Server>
 make_Server(
     Handler& handler,
-    boost::asio::io_context& io_context,
+    boost::asio::io_service& io_service,
     beast::Journal journal)
 {
-    return std::make_unique<ServerImpl<Handler>>(handler, io_context, journal);
+    return std::make_unique<ServerImpl<Handler>>(handler, io_service, journal);
 }
 
 }  // namespace ripple

include/xrpl/server/Session.h

@@ -86,7 +86,9 @@ public:
              ++iter)
         {
             typename BufferSequence::value_type const& buffer(*iter);
-            write(buffer.data(), boost::asio::buffer_size(buffer));
+            write(
+                boost::asio::buffer_cast<void const*>(buffer),
+                boost::asio::buffer_size(buffer));
         }
     }
 
@@ -100,7 +102,7 @@ public:
 
     /** Detach the session.
         This holds the session open so that the response can be sent
-        asynchronously. Calls to io_context::run made by the server
+        asynchronously. Calls to io_service::run made by the server
         will not return until all detached sessions are closed.
     */
     virtual std::shared_ptr<Session>

include/xrpl/server/detail/BaseHTTPPeer.h

@@ -24,12 +24,10 @@
 #include <xrpl/beast/net/IPAddressConversion.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/server/Session.h>
-#include <xrpl/server/detail/Spawn.h>
 #include <xrpl/server/detail/io_list.h>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/spawn.hpp>
 #include <boost/asio/ssl/stream.hpp>
-#include <boost/asio/strand.hpp>
 #include <boost/asio/streambuf.hpp>
 #include <boost/beast/core/stream_traits.hpp>
 #include <boost/beast/http/dynamic_body.hpp>
@@ -216,8 +214,8 @@ BaseHTTPPeer<Handler, Impl>::BaseHTTPPeer(
     ConstBufferSequence const& buffers)
     : port_(port)
     , handler_(handler)
-    , work_(boost::asio::make_work_guard(executor))
-    , strand_(boost::asio::make_strand(executor))
+    , work_(executor)
+    , strand_(executor)
     , remote_address_(remote_address)
     , journal_(journal)
 {
@@ -302,13 +300,7 @@ BaseHTTPPeer<Handler, Impl>::do_read(yield_context do_yield)
 {
     complete_ = false;
     error_code ec;
-    // Do not treat an established keep-alive waiting for its next request as
-    // an unfinished loopback request.
-    if (request_count_ == 0)
-        start_timer();
-    else
-        boost::beast::get_lowest_layer(impl().stream_)
-            .expires_after(std::chrono::seconds(timeoutSeconds));
+    start_timer();
     boost::beast::http::async_read(
         impl().stream_, read_buf_, message_, do_yield[ec]);
     cancel_timer();
@@ -363,7 +355,7 @@ BaseHTTPPeer<Handler, Impl>::on_write(
         return;
     if (graceful_)
         return do_close();
-    util::spawn(
+    boost::asio::spawn(
         strand_,
         std::bind(
             &BaseHTTPPeer<Handler, Impl>::do_read,
@@ -382,7 +374,7 @@ BaseHTTPPeer<Handler, Impl>::do_writer(
     {
         auto const p = impl().shared_from_this();
         resume = std::function<void(void)>([this, p, writer, keep_alive]() {
-            util::spawn(
+            boost::asio::spawn(
                 strand_,
                 std::bind(
                     &BaseHTTPPeer<Handler, Impl>::do_writer,
@@ -413,7 +405,7 @@ BaseHTTPPeer<Handler, Impl>::do_writer(
     if (!keep_alive)
         return do_close();
 
-    util::spawn(
+    boost::asio::spawn(
         strand_,
         std::bind(
             &BaseHTTPPeer<Handler, Impl>::do_read,
@@ -455,14 +447,14 @@ BaseHTTPPeer<Handler, Impl>::write(
     std::shared_ptr<Writer> const& writer,
     bool keep_alive)
 {
-    util::spawn(
+    boost::asio::spawn(bind_executor(
         strand_,
         std::bind(
             &BaseHTTPPeer<Handler, Impl>::do_writer,
             impl().shared_from_this(),
             writer,
             keep_alive,
-            std::placeholders::_1));
+            std::placeholders::_1)));
 }
 
 // DEPRECATED
@@ -497,12 +489,12 @@ BaseHTTPPeer<Handler, Impl>::complete()
     }
 
     // keep-alive
-    util::spawn(
+    boost::asio::spawn(bind_executor(
         strand_,
         std::bind(
             &BaseHTTPPeer<Handler, Impl>::do_read,
             impl().shared_from_this(),
-            std::placeholders::_1));
+            std::placeholders::_1)));
 }
 
 // DEPRECATED

include/xrpl/server/detail/BasePeer.h

@@ -89,8 +89,8 @@ BasePeer<Handler, Impl>::BasePeer(
               return "##" + std::to_string(++id) + " ";
           }())
     , j_(sink_)
-    , work_(boost::asio::make_work_guard(executor))
-    , strand_(boost::asio::make_strand(executor))
+    , work_(executor)
+    , strand_(executor)
 {
 }
 

include/xrpl/server/detail/BaseWSPeer.h

@@ -29,7 +29,6 @@
 #include <xrpl/server/detail/BasePeer.h>
 #include <xrpl/server/detail/LowestLayer.h>
 
-#include <boost/asio/error.hpp>
 #include <boost/beast/core/multi_buffer.hpp>
 #include <boost/beast/http/message.hpp>
 #include <boost/beast/websocket.hpp>
@@ -421,17 +420,11 @@ BaseWSPeer<Handler, Impl>::start_timer()
     // Max seconds without completing a message
     static constexpr std::chrono::seconds timeout{30};
     static constexpr std::chrono::seconds timeoutLocal{3};
-
-    try
-    {
-        timer_.expires_after(
-            remote_endpoint().address().is_loopback() ? timeoutLocal : timeout);
-    }
-    catch (boost::system::system_error const& e)
-    {
-        return fail(e.code(), "start_timer");
-    }
-
+    error_code ec;
+    timer_.expires_from_now(
+        remote_endpoint().address().is_loopback() ? timeoutLocal : timeout, ec);
+    if (ec)
+        return fail(ec, "start_timer");
     timer_.async_wait(bind_executor(
         strand_,
         std::bind(
@@ -445,14 +438,8 @@ template <class Handler, class Impl>
 void
 BaseWSPeer<Handler, Impl>::cancel_timer()
 {
-    try
-    {
-        timer_.cancel();
-    }
-    catch (boost::system::system_error const&)
-    {
-        // ignored
-    }
+    error_code ec;
+    timer_.cancel(ec);
 }
 
 template <class Handler, class Impl>

include/xrpl/server/detail/Door.h

@@ -69,7 +69,7 @@ private:
         stream_type stream_;
         socket_type& socket_;
         endpoint_type remote_address_;
-        boost::asio::strand<boost::asio::io_context::executor_type> strand_;
+        boost::asio::io_context::strand strand_;
         beast::Journal const j_;
 
     public:
@@ -95,7 +95,7 @@ private:
     Handler& handler_;
     boost::asio::io_context& ioc_;
     acceptor_type acceptor_;
-    boost::asio::strand<boost::asio::io_context::executor_type> strand_;
+    boost::asio::io_context::strand strand_;
     bool ssl_;
     bool plain_;
 
@@ -155,7 +155,7 @@ Door<Handler>::Detector::Detector(
     , stream_(std::move(stream))
     , socket_(stream_.socket())
     , remote_address_(remote_address)
-    , strand_(boost::asio::make_strand(ioc_))
+    , strand_(ioc_)
     , j_(j)
 {
 }
@@ -164,7 +164,7 @@ template <class Handler>
 void
 Door<Handler>::Detector::run()
 {
-    util::spawn(
+    boost::asio::spawn(
         strand_,
         std::bind(
             &Detector::do_detect,
@@ -269,7 +269,7 @@ Door<Handler>::reOpen()
         Throw<std::exception>();
     }
 
-    acceptor_.listen(boost::asio::socket_base::max_listen_connections, ec);
+    acceptor_.listen(boost::asio::socket_base::max_connections, ec);
     if (ec)
     {
         JLOG(j_.error()) << "Listen on port '" << port_.name
@@ -291,7 +291,7 @@ Door<Handler>::Door(
     , handler_(handler)
     , ioc_(io_context)
     , acceptor_(io_context)
-    , strand_(boost::asio::make_strand(io_context))
+    , strand_(io_context)
     , ssl_(
           port_.protocol.count("https") > 0 ||
           port_.protocol.count("wss") > 0 || port_.protocol.count("wss2") > 0 ||
@@ -307,7 +307,7 @@ template <class Handler>
 void
 Door<Handler>::run()
 {
-    util::spawn(
+    boost::asio::spawn(
         strand_,
         std::bind(
             &Door<Handler>::do_accept,
@@ -320,8 +320,7 @@ void
 Door<Handler>::close()
 {
     if (!strand_.running_in_this_thread())
-        return boost::asio::post(
-            strand_,
+        return strand_.post(
             std::bind(&Door<Handler>::close, this->shared_from_this()));
     error_code ec;
     acceptor_.close(ec);
@@ -401,7 +400,7 @@ Door<Handler>::do_accept(boost::asio::yield_context do_yield)
         {
             create(
                 ssl_,
-                boost::asio::const_buffer{},
+                boost::asio::null_buffers{},
                 std::move(stream),
                 remote_address);
         }

include/xrpl/server/detail/PlainHTTPPeer.h

@@ -103,7 +103,7 @@ PlainHTTPPeer<Handler>::run()
 {
     if (!this->handler_.onAccept(this->session(), this->remote_address_))
     {
-        util::spawn(
+        boost::asio::spawn(
             this->strand_,
             std::bind(&PlainHTTPPeer::do_close, this->shared_from_this()));
         return;
@@ -112,7 +112,7 @@ PlainHTTPPeer<Handler>::run()
     if (!socket_.is_open())
         return;
 
-    util::spawn(
+    boost::asio::spawn(
         this->strand_,
         std::bind(
             &PlainHTTPPeer::do_read,

include/xrpl/server/detail/SSLHTTPPeer.h

@@ -113,14 +113,14 @@ SSLHTTPPeer<Handler>::run()
 {
     if (!this->handler_.onAccept(this->session(), this->remote_address_))
     {
-        util::spawn(
+        boost::asio::spawn(
             this->strand_,
             std::bind(&SSLHTTPPeer::do_close, this->shared_from_this()));
         return;
     }
     if (!socket_.is_open())
         return;
-    util::spawn(
+    boost::asio::spawn(
         this->strand_,
         std::bind(
             &SSLHTTPPeer::do_handshake,
@@ -162,7 +162,7 @@ SSLHTTPPeer<Handler>::do_handshake(yield_context do_yield)
         this->port().protocol.count("https") > 0;
     if (http)
     {
-        util::spawn(
+        boost::asio::spawn(
             this->strand_,
             std::bind(
                 &SSLHTTPPeer::do_read,

include/xrpl/server/detail/ServerImpl.h

@@ -27,8 +27,6 @@
 #include <xrpl/server/detail/io_list.h>
 
 #include <boost/asio.hpp>
-#include <boost/asio/executor_work_guard.hpp>
-#include <boost/asio/io_context.hpp>
 
 #include <array>
 #include <chrono>
@@ -88,11 +86,9 @@ private:
 
     Handler& handler_;
     beast::Journal const j_;
-    boost::asio::io_context& io_context_;
-    boost::asio::strand<boost::asio::io_context::executor_type> strand_;
-    std::optional<boost::asio::executor_work_guard<
-        boost::asio::io_context::executor_type>>
-        work_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::strand strand_;
+    std::optional<boost::asio::io_service::work> work_;
 
     std::mutex m_;
     std::vector<Port> ports_;
@@ -105,7 +101,7 @@ private:
 public:
     ServerImpl(
         Handler& handler,
-        boost::asio::io_context& io_context,
+        boost::asio::io_service& io_service,
         beast::Journal journal);
 
     ~ServerImpl();
@@ -128,10 +124,10 @@ public:
         return ios_;
     }
 
-    boost::asio::io_context&
-    get_io_context()
+    boost::asio::io_service&
+    get_io_service()
     {
-        return io_context_;
+        return io_service_;
     }
 
     bool
@@ -145,13 +141,13 @@ private:
 template <class Handler>
 ServerImpl<Handler>::ServerImpl(
     Handler& handler,
-    boost::asio::io_context& io_context,
+    boost::asio::io_service& io_service,
     beast::Journal journal)
     : handler_(handler)
     , j_(journal)
-    , io_context_(io_context)
-    , strand_(boost::asio::make_strand(io_context_))
-    , work_(std::in_place, boost::asio::make_work_guard(io_context_))
+    , io_service_(io_service)
+    , strand_(io_service_)
+    , work_(io_service_)
 {
 }
 
@@ -183,7 +179,7 @@ ServerImpl<Handler>::ports(std::vector<Port> const& ports)
         {
             // UDP-RPC door
             if (auto sp = ios_.emplace<UDPDoor<Handler>>(
-                    handler_, io_context_, internalPort, j_))
+                    handler_, io_service_, internalPort, j_))
             {
                 auto ep = sp->get_endpoint();
                 if (!internalPort.port)
@@ -197,7 +193,7 @@ ServerImpl<Handler>::ports(std::vector<Port> const& ports)
         {
             // Standard TCP door
             if (auto sp = ios_.emplace<Door<Handler>>(
-                    handler_, io_context_, internalPort, j_))
+                    handler_, io_service_, internalPort, j_))
             {
                 list_.push_back(sp);
 

include/xrpl/server/detail/Spawn.h

@@ -1,111 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright(c) 2025 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_SERVER_SPAWN_H_INCLUDED
-#define RIPPLE_SERVER_SPAWN_H_INCLUDED
-
-#include <xrpl/basics/Log.h>
-
-#include <boost/asio/spawn.hpp>
-#include <boost/asio/strand.hpp>
-
-#include <concepts>
-#include <type_traits>
-
-namespace ripple::util {
-namespace impl {
-
-template <typename T>
-concept IsStrand = std::same_as<
-    std::decay_t<T>,
-    boost::asio::strand<typename std::decay_t<T>::inner_executor_type>>;
-
-/**
- * @brief A completion handler that restores `boost::asio::spawn`'s behaviour
- * from Boost 1.83
- *
- * This is intended to be passed as the third argument to `boost::asio::spawn`
- * so that exceptions are not ignored but propagated to `io_context.run()` call
- * site.
- *
- * @param ePtr The exception that was caught on the coroutine
- */
-inline constexpr auto kPROPAGATE_EXCEPTIONS = [](std::exception_ptr ePtr) {
-    if (ePtr)
-    {
-        try
-        {
-            std::rethrow_exception(ePtr);
-        }
-        catch (std::exception const& e)
-        {
-            JLOG(debugLog().warn()) << "Spawn exception: " << e.what();
-            throw;
-        }
-        catch (...)
-        {
-            JLOG(debugLog().warn()) << "Spawn exception: Unknown";
-            throw;
-        }
-    }
-};
-
-}  // namespace impl
-
-/**
- * @brief Spawns a coroutine using `boost::asio::spawn`
- *
- * @note This uses kPROPAGATE_EXCEPTIONS to force asio to propagate exceptions
- * through `io_context`
- * @note Since implicit strand was removed from boost::asio::spawn this helper
- * function adds the strand back
- *
- * @tparam Ctx The type of the context/strand
- * @tparam F The type of the function to execute
- * @param ctx The execution context
- * @param func The function to execute. Must return `void`
- */
-template <typename Ctx, typename F>
-    requires std::is_invocable_r_v<void, F, boost::asio::yield_context>
-void
-spawn(Ctx&& ctx, F&& func)
-{
-    if constexpr (impl::IsStrand<Ctx>)
-    {
-        boost::asio::spawn(
-            std::forward<Ctx>(ctx),
-            std::forward<F>(func),
-            impl::kPROPAGATE_EXCEPTIONS);
-    }
-    else
-    {
-        // make_strand accepts an executor or an execution context directly.
-        // Going through get_associated_executor here resolved a plain
-        // executor to asio's inline executor, which cannot be stranded and
-        // did not compile; nothing in the tree had instantiated this branch.
-        boost::asio::spawn(
-            boost::asio::make_strand(std::forward<Ctx>(ctx)),
-            std::forward<F>(func),
-            impl::kPROPAGATE_EXCEPTIONS);
-    }
-}
-
-}  // namespace ripple::util
-
-#endif

include/xrpl/server/detail/io_list.h

@@ -166,7 +166,7 @@ public:
             May be called concurrently.
 
         Preconditions:
-            No call to io_context::run on any io_context
+            No call to io_service::run on any io_service
             used by work objects associated with this io_list
             exists in the caller's call stack.
     */

release-builder.sh

@@ -11,11 +11,11 @@ echo "START BUILDING (HOST)"
 echo "Cleaning previously built binary"
 rm -f release-build/xahaud
 
-BUILD_CORES=$(echo "scale=0 ; $(nproc) / 1.337" | bc)
+BUILD_CORES=$(echo "scale=0 ; `nproc` / 1.337" | bc)
 
 if [[ "$GITHUB_REPOSITORY" == "" ]]; then
   #Default
-  BUILD_CORES=${BUILD_CORES:-8}
+  BUILD_CORES=${BUILD_CORES:-8} 
 fi
 
 # Ensure still works outside of GH Actions by setting these to /dev/null
@@ -31,19 +31,21 @@ echo "-- GITHUB_SHA:        $GITHUB_SHA"
 echo "-- GITHUB_RUN_NUMBER: $GITHUB_RUN_NUMBER"
 echo "-- CONTAINER_NAME:    $CONTAINER_NAME"
 
-which docker 2>/dev/null 2>/dev/null
-if [ "$?" -eq "1" ]; then
+which docker 2> /dev/null 2> /dev/null
+if [ "$?" -eq "1" ]
+then
   echo 'Docker not found. Install it first.'
   exit 1
 fi
 
-stat .git 2>/dev/null 2>/dev/null
-if [ "$?" -eq "1" ]; then
+stat .git 2> /dev/null 2> /dev/null
+if [ "$?" -eq "1" ]
+then
   echo 'Run this inside the source directory. (.git dir not found).'
   exit 1
 fi
 
-STATIC_CONTAINER=$(docker ps -a | grep $CONTAINER_NAME | wc -l)
+STATIC_CONTAINER=$(docker ps -a | grep $CONTAINER_NAME |wc -l)
 
 CACHE_VOLUME_NAME="xahau-release-builder-cache"
 
@@ -55,14 +57,13 @@ if false; then
   docker stop $CONTAINER_NAME
 else
   echo "No static container, build on temp container"
-  rm -rf release-build
-  mkdir -p release-build
+  rm -rf release-build;
+  mkdir -p release-build;
 
   docker volume create $CACHE_VOLUME_NAME
 
   # Create inline Dockerfile with environment setup for build-full.sh
-  DOCKERFILE_CONTENT=$(
-    cat <<'DOCKERFILE_EOF'
+  DOCKERFILE_CONTENT=$(cat <<'DOCKERFILE_EOF'
 FROM ghcr.io/phusion/holy-build-box:4.0.1-amd64
 
 ARG BUILD_CORES=8
@@ -217,7 +218,7 @@ RUN /hbb_exe/activate-exec bash -c "ccache -M 100G && \
     ln -s ../../bin/ccache /usr/lib64/ccache/c++"
 
 DOCKERFILE_EOF
-  )
+)
 
   # Build custom Docker image
   IMAGE_NAME="xahaud-builder:latest"
@@ -227,14 +228,14 @@ 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 /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'"
+    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 /data/builds:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash
+    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 /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

src/libxrpl/basics/ResolverAsio.cpp

@@ -22,14 +22,7 @@
 #include <xrpl/beast/net/IPAddressConversion.h>
 #include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
-#include <boost/asio/bind_executor.hpp>
-#include <boost/asio/error.hpp>
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/system/detail/error_code.hpp>
-
-#include <algorithm>
+#include <boost/asio.hpp>
 #include <atomic>
 #include <condition_variable>
 #include <deque>
@@ -117,8 +110,8 @@ public:
 
     beast::Journal m_journal;
 
-    boost::asio::io_context& m_io_context;
-    boost::asio::strand<boost::asio::io_context::executor_type> m_strand;
+    boost::asio::io_service& m_io_service;
+    boost::asio::io_service::strand m_strand;
     boost::asio::ip::tcp::resolver m_resolver;
 
     std::condition_variable m_cv;
@@ -148,12 +141,12 @@ public:
     std::deque<Work> m_work;
 
     ResolverAsioImpl(
-        boost::asio::io_context& io_context,
+        boost::asio::io_service& io_service,
         beast::Journal journal)
         : m_journal(journal)
-        , m_io_context(io_context)
-        , m_strand(boost::asio::make_strand(io_context))
-        , m_resolver(io_context)
+        , m_io_service(io_service)
+        , m_strand(io_service)
+        , m_resolver(io_service)
         , m_asyncHandlersCompleted(true)
         , m_stop_called(false)
         , m_stopped(true)
@@ -209,14 +202,8 @@ public:
     {
         if (m_stop_called.exchange(true) == false)
         {
-            boost::asio::dispatch(
-                m_io_context,
-                boost::asio::bind_executor(
-                    m_strand,
-                    std::bind(
-                        &ResolverAsioImpl::do_stop,
-                        this,
-                        CompletionCounter(this))));
+            m_io_service.dispatch(m_strand.wrap(std::bind(
+                &ResolverAsioImpl::do_stop, this, CompletionCounter(this))));
 
             JLOG(m_journal.debug()) << "Queued a stop request";
         }
@@ -247,16 +234,12 @@ public:
 
         // TODO NIKB use rvalue references to construct and move
         //           reducing cost.
-        boost::asio::dispatch(
-            m_io_context,
-            boost::asio::bind_executor(
-                m_strand,
-                std::bind(
-                    &ResolverAsioImpl::do_resolve,
-                    this,
-                    names,
-                    handler,
-                    CompletionCounter(this))));
+        m_io_service.dispatch(m_strand.wrap(std::bind(
+            &ResolverAsioImpl::do_resolve,
+            this,
+            names,
+            handler,
+            CompletionCounter(this))));
     }
 
     //-------------------------------------------------------------------------
@@ -282,20 +265,19 @@ public:
         std::string name,
         boost::system::error_code const& ec,
         HandlerType handler,
-        boost::asio::ip::tcp::resolver::results_type results,
+        boost::asio::ip::tcp::resolver::iterator iter,
         CompletionCounter)
     {
         if (ec == boost::asio::error::operation_aborted)
             return;
 
         std::vector<beast::IP::Endpoint> addresses;
-        auto iter = results.begin();
 
         // If we get an error message back, we don't return any
         // results that we may have gotten.
         if (!ec)
         {
-            while (iter != results.end())
+            while (iter != boost::asio::ip::tcp::resolver::iterator())
             {
                 addresses.push_back(
                     beast::IPAddressConversion::from_asio(*iter));
@@ -305,14 +287,8 @@ public:
 
         handler(name, addresses);
 
-        boost::asio::post(
-            m_io_context,
-            boost::asio::bind_executor(
-                m_strand,
-                std::bind(
-                    &ResolverAsioImpl::do_work,
-                    this,
-                    CompletionCounter(this))));
+        m_io_service.post(m_strand.wrap(std::bind(
+            &ResolverAsioImpl::do_work, this, CompletionCounter(this))));
     }
 
     HostAndPort
@@ -393,21 +369,16 @@ public:
         {
             JLOG(m_journal.error()) << "Unable to parse '" << name << "'";
 
-            boost::asio::post(
-                m_io_context,
-                boost::asio::bind_executor(
-                    m_strand,
-                    std::bind(
-                        &ResolverAsioImpl::do_work,
-                        this,
-                        CompletionCounter(this))));
+            m_io_service.post(m_strand.wrap(std::bind(
+                &ResolverAsioImpl::do_work, this, CompletionCounter(this))));
 
             return;
         }
 
+        boost::asio::ip::tcp::resolver::query query(host, port);
+
         m_resolver.async_resolve(
-            host,
-            port,
+            query,
             std::bind(
                 &ResolverAsioImpl::do_finish,
                 this,
@@ -438,14 +409,10 @@ public:
 
             if (m_work.size() > 0)
             {
-                boost::asio::post(
-                    m_io_context,
-                    boost::asio::bind_executor(
-                        m_strand,
-                        std::bind(
-                            &ResolverAsioImpl::do_work,
-                            this,
-                            CompletionCounter(this))));
+                m_io_service.post(m_strand.wrap(std::bind(
+                    &ResolverAsioImpl::do_work,
+                    this,
+                    CompletionCounter(this))));
             }
         }
     }
@@ -454,9 +421,9 @@ public:
 //-----------------------------------------------------------------------------
 
 std::unique_ptr<ResolverAsio>
-ResolverAsio::New(boost::asio::io_context& io_context, beast::Journal journal)
+ResolverAsio::New(boost::asio::io_service& io_service, beast::Journal journal)
 {
-    return std::make_unique<ResolverAsioImpl>(io_context, journal);
+    return std::make_unique<ResolverAsioImpl>(io_service, journal);
 }
 
 //-----------------------------------------------------------------------------

src/libxrpl/basics/UTF8.cpp

@@ -1,101 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2025 XRPL Labs
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#include <xrpl/basics/UTF8.h>
-
-namespace ripple {
-
-bool
-isValidUTF8(Slice const& s) noexcept
-{
-    std::size_t const size = s.size();
-
-    // Markus Kuhn's utf8_check.c
-    // (https://www.cl.cam.ac.uk/~mgk25/ucs/utf8_check.c), the decoder
-    // URIToken has always used, with one change: each branch establishes
-    // that the whole sequence is present before reading any continuation
-    // byte, so a truncated tail is invalid rather than an out-of-bounds read.
-    std::size_t i = 0;
-    while (i < size)
-    {
-        std::uint8_t const c0 = s[i];
-
-        if (c0 < 0x80)
-        {
-            // 0xxxxxxx
-            ++i;
-            continue;
-        }
-
-        if ((c0 & 0xE0) == 0xC0)
-        {
-            // 110xxxxx 10xxxxxx
-            if (size - i < 2)
-                return false;
-            if ((s[i + 1] & 0xC0) != 0x80)
-                return false;
-            if ((c0 & 0xFE) == 0xC0)  // overlong
-                return false;
-            i += 2;
-            continue;
-        }
-
-        if ((c0 & 0xF0) == 0xE0)
-        {
-            // 1110xxxx 10xxxxxx 10xxxxxx
-            if (size - i < 3)
-                return false;
-            std::uint8_t const c1 = s[i + 1];
-            if ((c1 & 0xC0) != 0x80 || (s[i + 2] & 0xC0) != 0x80)
-                return false;
-            if (c0 == 0xE0 && (c1 & 0xE0) == 0x80)  // overlong
-                return false;
-            if (c0 == 0xED && (c1 & 0xE0) == 0xA0)  // UTF-16 surrogate
-                return false;
-            if (c0 == 0xEF && c1 == 0xBF &&
-                (s[i + 2] & 0xFE) == 0xBE)  // U+FFFE or U+FFFF
-                return false;
-            i += 3;
-            continue;
-        }
-
-        if ((c0 & 0xF8) == 0xF0)
-        {
-            // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-            if (size - i < 4)
-                return false;
-            std::uint8_t const c1 = s[i + 1];
-            if ((c1 & 0xC0) != 0x80 || (s[i + 2] & 0xC0) != 0x80 ||
-                (s[i + 3] & 0xC0) != 0x80)
-                return false;
-            if (c0 == 0xF0 && (c1 & 0xF0) == 0x80)  // overlong
-                return false;
-            if (c0 > 0xF4 || (c0 == 0xF4 && c1 > 0x8F))  // > U+10FFFF
-                return false;
-            i += 4;
-            continue;
-        }
-
-        // Stray continuation byte or 0xF8..0xFF.
-        return false;
-    }
-    return true;
-}
-
-}  // namespace ripple

src/libxrpl/beast/insight/StatsDCollector.cpp

@@ -26,24 +26,10 @@
 #include <xrpl/beast/insight/StatsDCollector.h>
 #include <xrpl/beast/net/IPAddressConversion.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
-#include <boost/asio/basic_waitable_timer.hpp>
-#include <boost/asio/bind_executor.hpp>
-#include <boost/asio/buffer.hpp>
-#include <boost/asio/error.hpp>
-#include <boost/asio/executor_work_guard.hpp>
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/ip/udp.hpp>
-#include <boost/asio/strand.hpp>
-#include <boost/system/detail/error_code.hpp>
-
 #include <boost/asio/ip/tcp.hpp>
-#include <chrono>
 #include <climits>
-#include <cstddef>
 #include <deque>
 #include <functional>
-#include <iostream>
 #include <mutex>
 #include <optional>
 #include <set>
@@ -237,11 +223,9 @@ private:
     Journal m_journal;
     IP::Endpoint m_address;
     std::string m_prefix;
-    boost::asio::io_context m_io_context;
-    std::optional<boost::asio::executor_work_guard<
-        boost::asio::io_context::executor_type>>
-        m_work;
-    boost::asio::strand<boost::asio::io_context::executor_type> m_strand;
+    boost::asio::io_service m_io_service;
+    std::optional<boost::asio::io_service::work> m_work;
+    boost::asio::io_service::strand m_strand;
     boost::asio::basic_waitable_timer<std::chrono::steady_clock> m_timer;
     boost::asio::ip::udp::socket m_socket;
     std::deque<std::string> m_data;
@@ -265,24 +249,18 @@ public:
         : m_journal(journal)
         , m_address(address)
         , m_prefix(prefix)
-        , m_work(boost::asio::make_work_guard(m_io_context))
-        , m_strand(boost::asio::make_strand(m_io_context))
-        , m_timer(m_io_context)
-        , m_socket(m_io_context)
+        , m_work(std::ref(m_io_service))
+        , m_strand(m_io_service)
+        , m_timer(m_io_service)
+        , m_socket(m_io_service)
         , m_thread(&StatsDCollectorImp::run, this)
     {
     }
 
     ~StatsDCollectorImp() override
     {
-        try
-        {
-            m_timer.cancel();
-        }
-        catch (boost::system::system_error const&)
-        {
-            // ignored
-        }
+        boost::system::error_code ec;
+        m_timer.cancel(ec);
 
         m_work.reset();
         m_thread.join();
@@ -341,10 +319,10 @@ public:
 
     //--------------------------------------------------------------------------
 
-    boost::asio::io_context&
-    get_io_context()
+    boost::asio::io_service&
+    get_io_service()
     {
-        return m_io_context;
+        return m_io_service;
     }
 
     std::string const&
@@ -362,14 +340,8 @@ public:
     void
     post_buffer(std::string&& buffer)
     {
-        boost::asio::dispatch(
-            m_io_context,
-            boost::asio::bind_executor(
-                m_strand,
-                std::bind(
-                    &StatsDCollectorImp::do_post_buffer,
-                    this,
-                    std::move(buffer))));
+        m_io_service.dispatch(m_strand.wrap(std::bind(
+            &StatsDCollectorImp::do_post_buffer, this, std::move(buffer))));
     }
 
     // The keepAlive parameter makes sure the buffers sent to
@@ -399,7 +371,7 @@ public:
         for (auto const& buffer : buffers)
         {
             std::string const s(
-                static_cast<char const*>(buffer.data()),
+                boost::asio::buffer_cast<char const*>(buffer),
                 boost::asio::buffer_size(buffer));
             std::cerr << s;
         }
@@ -469,7 +441,7 @@ public:
     set_timer()
     {
         using namespace std::chrono_literals;
-        m_timer.expires_after(1s);
+        m_timer.expires_from_now(1s);
         m_timer.async_wait(std::bind(
             &StatsDCollectorImp::on_timer, this, std::placeholders::_1));
     }
@@ -511,13 +483,13 @@ public:
 
         set_timer();
 
-        m_io_context.run();
+        m_io_service.run();
 
         m_socket.shutdown(boost::asio::ip::udp::socket::shutdown_send, ec);
 
         m_socket.close();
 
-        m_io_context.poll();
+        m_io_service.poll();
     }
 };
 
@@ -560,12 +532,10 @@ StatsDCounterImpl::~StatsDCounterImpl()
 void
 StatsDCounterImpl::increment(CounterImpl::value_type amount)
 {
-    boost::asio::dispatch(
-        m_impl->get_io_context(),
-        std::bind(
-            &StatsDCounterImpl::do_increment,
-            std::static_pointer_cast<StatsDCounterImpl>(shared_from_this()),
-            amount));
+    m_impl->get_io_service().dispatch(std::bind(
+        &StatsDCounterImpl::do_increment,
+        std::static_pointer_cast<StatsDCounterImpl>(shared_from_this()),
+        amount));
 }
 
 void
@@ -607,12 +577,10 @@ StatsDEventImpl::StatsDEventImpl(
 void
 StatsDEventImpl::notify(EventImpl::value_type const& value)
 {
-    boost::asio::dispatch(
-        m_impl->get_io_context(),
-        std::bind(
-            &StatsDEventImpl::do_notify,
-            std::static_pointer_cast<StatsDEventImpl>(shared_from_this()),
-            value));
+    m_impl->get_io_service().dispatch(std::bind(
+        &StatsDEventImpl::do_notify,
+        std::static_pointer_cast<StatsDEventImpl>(shared_from_this()),
+        value));
 }
 
 void
@@ -642,23 +610,19 @@ StatsDGaugeImpl::~StatsDGaugeImpl()
 void
 StatsDGaugeImpl::set(GaugeImpl::value_type value)
 {
-    boost::asio::dispatch(
-        m_impl->get_io_context(),
-        std::bind(
-            &StatsDGaugeImpl::do_set,
-            std::static_pointer_cast<StatsDGaugeImpl>(shared_from_this()),
-            value));
+    m_impl->get_io_service().dispatch(std::bind(
+        &StatsDGaugeImpl::do_set,
+        std::static_pointer_cast<StatsDGaugeImpl>(shared_from_this()),
+        value));
 }
 
 void
 StatsDGaugeImpl::increment(GaugeImpl::difference_type amount)
 {
-    boost::asio::dispatch(
-        m_impl->get_io_context(),
-        std::bind(
-            &StatsDGaugeImpl::do_increment,
-            std::static_pointer_cast<StatsDGaugeImpl>(shared_from_this()),
-            amount));
+    m_impl->get_io_service().dispatch(std::bind(
+        &StatsDGaugeImpl::do_increment,
+        std::static_pointer_cast<StatsDGaugeImpl>(shared_from_this()),
+        amount));
 }
 
 void
@@ -734,12 +698,10 @@ StatsDMeterImpl::~StatsDMeterImpl()
 void
 StatsDMeterImpl::increment(MeterImpl::value_type amount)
 {
-    boost::asio::dispatch(
-        m_impl->get_io_context(),
-        std::bind(
-            &StatsDMeterImpl::do_increment,
-            std::static_pointer_cast<StatsDMeterImpl>(shared_from_this()),
-            amount));
+    m_impl->get_io_service().dispatch(std::bind(
+        &StatsDMeterImpl::do_increment,
+        std::static_pointer_cast<StatsDMeterImpl>(shared_from_this()),
+        amount));
 }
 
 void

src/libxrpl/beast/net/IPAddressV4.cpp

@@ -28,11 +28,11 @@ namespace IP {
 bool
 is_private(AddressV4 const& addr)
 {
-    return ((addr.to_uint() & 0xff000000) ==
+    return ((addr.to_ulong() & 0xff000000) ==
             0x0a000000) ||  // Prefix /8,    10.  #.#.#
-        ((addr.to_uint() & 0xfff00000) ==
+        ((addr.to_ulong() & 0xfff00000) ==
          0xac100000) ||  // Prefix /12   172. 16.#.# - 172.31.#.#
-        ((addr.to_uint() & 0xffff0000) ==
+        ((addr.to_ulong() & 0xffff0000) ==
          0xc0a80000) ||  // Prefix /16   192.168.#.#
         addr.is_loopback();
 }
@@ -47,7 +47,7 @@ char
 get_class(AddressV4 const& addr)
 {
     static char const* table = "AAAABBCD";
-    return table[(addr.to_uint() & 0xE0000000) >> 29];
+    return table[(addr.to_ulong() & 0xE0000000) >> 29];
 }
 
 }  // namespace IP

src/libxrpl/beast/net/IPAddressV6.cpp

@@ -20,8 +20,6 @@
 #include <xrpl/beast/net/IPAddressV4.h>
 #include <xrpl/beast/net/IPAddressV6.h>
 
-#include <boost/asio/ip/address_v4.hpp>
-
 namespace beast {
 namespace IP {
 
@@ -30,9 +28,7 @@ is_private(AddressV6 const& addr)
 {
     return (
         (addr.to_bytes()[0] & 0xfd) ||  // TODO  fc00::/8 too ?
-        (addr.is_v4_mapped() &&
-         is_private(boost::asio::ip::make_address_v4(
-             boost::asio::ip::v4_mapped, addr))));
+        (addr.is_v4_mapped() && is_private(addr.to_v4())));
 }
 
 bool

src/libxrpl/beast/net/IPEndpoint.cpp

@@ -18,19 +18,7 @@
 //==============================================================================
 
 #include <xrpl/beast/net/IPEndpoint.h>
-
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/asio/ip/address.hpp>
-#include <boost/asio/ip/address_v4.hpp>
-#include <boost/system/detail/error_code.hpp>
-
 #include <boost/algorithm/string.hpp>
-#include <cctype>
-#include <ios>
-#include <istream>
-#include <optional>
-#include <sstream>
-#include <string>
 
 namespace beast {
 namespace IP {
@@ -169,7 +157,7 @@ operator>>(std::istream& is, Endpoint& endpoint)
     }
 
     boost::system::error_code ec;
-    auto addr = boost::asio::ip::make_address(addrStr, ec);
+    auto addr = Address::from_string(addrStr, ec);
     if (ec)
     {
         is.setstate(std::ios_base::failbit);

src/libxrpl/protocol/AMMCore.cpp

@@ -66,7 +66,7 @@ invalidAMMAsset(
     Issue const& issue,
     std::optional<std::pair<Issue, Issue>> const& pair)
 {
-    if (isBadCurrency(issue.currency))
+    if (badCurrency() == issue.currency)
         return temBAD_CURRENCY;
     if (isXRP(issue) && issue.account.isNonZero())
         return temBAD_ISSUER;

src/libxrpl/protocol/BuildInfo.cpp

@@ -56,9 +56,9 @@ getVersionString()
         (versionString == std::string("0.") + std::string("0.0") ||
          versionString == std::string("0.0.0+DEBUG")))
     {
-        std::string y = std::string(&__DATE__[7]);
+        std::string y = std::string(__DATE__ + 7);
         std::string d = std::string(
-            &__DATE__[4 + (__DATE__[4] == ' ' ? 1 : 0)],
+            __DATE__ + 4 + (__DATE__[4] == ' ' ? 1 : 0),
             __DATE__[4] == ' ' ? 1 : 2);
         std::string m;
         switch (__DATE__[0])

src/libxrpl/protocol/Feature.cpp

@@ -250,9 +250,12 @@ FeatureCollections::registerFeature(
     Feature const* i = getByName(name);
     if (!i)
     {
+        // If this check fails, and you just added a feature, increase the
+        // numFeatures value in Feature.h
         check(
             features.size() < detail::numFeatures,
-            "More features defined than allocated.");
+            "More features defined than allocated. Adjust numFeatures in "
+            "Feature.h.");
 
         auto const f = sha512Half(Slice(name.data(), name.size()));
 
@@ -421,26 +424,45 @@ featureToName(uint256 const& f)
 #undef XRPL_FEATURE
 #pragma push_macro("XRPL_FIX")
 #undef XRPL_FIX
-#pragma push_macro("XRPL_RETIRE")
-#undef XRPL_RETIRE
 
 #define XRPL_FEATURE(name, supported, vote) \
     uint256 const feature##name = registerFeature(#name, supported, vote);
 #define XRPL_FIX(name, supported, vote) \
     uint256 const fix##name = registerFeature("fix" #name, supported, vote);
-#define XRPL_RETIRE(name)                                                     \
-    [[deprecated("The referenced amendment has been retired"), maybe_unused]] \
-    uint256 const retired##name = retireFeature(#name);
 
 #include <xrpl/protocol/detail/features.macro>
 
-#undef XRPL_RETIRE
-#pragma pop_macro("XRPL_RETIRE")
 #undef XRPL_FIX
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE
 #pragma pop_macro("XRPL_FEATURE")
 
+// clang-format off
+
+// The following amendments have been active for at least two years. Their
+// pre-amendment code has been removed and the identifiers are deprecated.
+// All known amendments and amendments that may appear in a validated
+// ledger must be registered either here or above with the "active" amendments
+[[deprecated("The referenced amendment has been retired"), maybe_unused]]
+uint256 const
+    retiredMultiSign         = retireFeature("MultiSign"),
+    retiredTrustSetAuth      = retireFeature("TrustSetAuth"),
+    retiredFeeEscalation     = retireFeature("FeeEscalation"),
+    retiredPayChan           = retireFeature("PayChan"),
+    retiredCryptoConditions  = retireFeature("CryptoConditions"),
+    retiredTickSize          = retireFeature("TickSize"),
+    retiredFix1368           = retireFeature("fix1368"),
+    retiredEscrow            = retireFeature("Escrow"),
+    retiredFix1373           = retireFeature("fix1373"),
+    retiredEnforceInvariants = retireFeature("EnforceInvariants"),
+    retiredSortedDirectories = retireFeature("SortedDirectories"),
+    retiredFix1201           = retireFeature("fix1201"),
+    retiredFix1512           = retireFeature("fix1512"),
+    retiredFix1523           = retireFeature("fix1523"),
+    retiredFix1528           = retireFeature("fix1528");
+
+// clang-format on
+
 // All of the features should now be registered, since variables in a cpp file
 // are initialized from top to bottom.
 //

src/libxrpl/protocol/Indexes.cpp

@@ -31,8 +31,6 @@
 
 namespace ripple {
 
-#define LEDGER_NAMESPACE2(value1, value2) (uint16_t(value1) << 8) | value2
-
 /** Type-specific prefix for calculating ledger indices.
 
     The identifier for a given object within the ledger is calculated based
@@ -82,15 +80,14 @@ enum class LedgerNameSpace : std::uint16_t {
     UNL_REPORT = 'R',
     CRON = 'L',
     AMM = 'A',
-    BRIDGE = LEDGER_NAMESPACE2(0x01, 'H'),
+    BRIDGE = 'H',
     XCHAIN_CLAIM_ID = 'Q',
     XCHAIN_CREATE_ACCOUNT_CLAIM_ID = 'K',
-    DID = LEDGER_NAMESPACE2(0x01, 'I'),
-    ORACLE = LEDGER_NAMESPACE2(0x01, 'R'),
+    DID = 'I',
+    ORACLE = 'R',
     MPTOKEN_ISSUANCE = '~',
     MPTOKEN = 't',
-    MANIFEST = 'M',
-    CREDENTIAL = LEDGER_NAMESPACE2(0x01, 'D'),
+    CREDENTIAL = 'D',
     PERMISSIONED_DOMAIN = 'm',
 
     // No longer used or supported. Left here to reserve the space
@@ -671,12 +668,6 @@ permissionedDomain(uint256 const& domainID) noexcept
     return {ltPERMISSIONED_DOMAIN, domainID};
 }
 
-Keylet
-manifest(PublicKey const& pk) noexcept
-{
-    return {ltMANIFEST, indexHash(LedgerNameSpace::MANIFEST, pk.slice())};
-}
-
 }  // namespace keylet
 
 }  // namespace ripple

src/libxrpl/protocol/InnerObjectFormats.cpp

@@ -87,6 +87,19 @@ InnerObjectFormats::InnerObjectFormats()
          {sfEmittedTxnID, soeREQUIRED},
          {sfEmitNonce, soeOPTIONAL}});
 
+    add(sfHookDefinition.jsonName,
+        sfHookDefinition.getCode(),
+        {{sfCreateCode, soeREQUIRED},
+         {sfHookNamespace, soeREQUIRED},
+         {sfHookParameters, soeREQUIRED},
+         {sfHookOn, soeOPTIONAL},
+         {sfHookOnIncoming, soeOPTIONAL},
+         {sfHookOnOutgoing, soeOPTIONAL},
+         {sfHookCanEmit, soeOPTIONAL},
+         {sfHookApiVersion, soeREQUIRED},
+         {sfFlags, soeREQUIRED},
+         {sfFee, soeREQUIRED}});
+
     add(sfHook.jsonName,
         sfHook.getCode(),
         {{sfHookHash, soeOPTIONAL},
@@ -99,7 +112,6 @@ InnerObjectFormats::InnerObjectFormats()
          {sfHookOnOutgoing, soeOPTIONAL},
          {sfHookCanEmit, soeOPTIONAL},
          {sfHookApiVersion, soeOPTIONAL},
-         {sfHookName, soeOPTIONAL},
          {sfFlags, soeOPTIONAL}});
 
     add(sfHookGrant.jsonName,
@@ -254,24 +266,6 @@ InnerObjectFormats::InnerObjectFormats()
             {sfIssuer, soeREQUIRED},
             {sfCredentialType, soeREQUIRED},
         });
-
-    add(sfHighReward.jsonName,
-        sfHighReward.getCode(),
-        {
-            {sfRewardLgrFirst, soeREQUIRED},
-            {sfRewardLgrLast, soeREQUIRED},
-            {sfRewardTime, soeREQUIRED},
-            {sfTrustLineRewardAccumulator, soeREQUIRED},
-        });
-
-    add(sfLowReward.jsonName,
-        sfLowReward.getCode(),
-        {
-            {sfRewardLgrFirst, soeREQUIRED},
-            {sfRewardLgrLast, soeREQUIRED},
-            {sfRewardTime, soeREQUIRED},
-            {sfTrustLineRewardAccumulator, soeREQUIRED},
-        });
 }
 
 InnerObjectFormats const&

src/libxrpl/protocol/Issue.cpp

@@ -111,7 +111,7 @@ issueFromJson(Json::Value const& v)
     }
 
     auto const currency = to_currency(curStr.asString());
-    if (isBadCurrency(currency) || currency == noCurrency())
+    if (currency == badCurrency() || currency == noCurrency())
     {
         Throw<Json::error>("issueFromJson currency must be a valid currency");
     }

src/libxrpl/protocol/STCurrency.cpp

@@ -103,7 +103,7 @@ currencyFromJson(SField const& name, Json::Value const& v)
     }
 
     auto const currency = to_currency(v.asString());
-    if (isBadCurrency(currency) || currency == noCurrency())
+    if (currency == badCurrency() || currency == noCurrency())
     {
         Throw<std::runtime_error>(
             "currencyFromJson currency must be a valid currency");

src/libxrpl/protocol/TER.cpp

@@ -151,8 +151,6 @@ transResults()
         MAKE_ERROR(tefNONDIR_EMIT,                 "An emitted txn was injected into the ledger without a corresponding directory entry."),
         MAKE_ERROR(tefIMPORT_BLACKHOLED,           "Cannot import keying because target account is blackholed."),
         MAKE_ERROR(tefINVALID_LEDGER_FIX_TYPE,     "The LedgerFixType field has an invalid value."),
-        MAKE_ERROR(tefPAST_MANIFEST_SEQ,           "The submitted manifest's sequence is not newer than the current."),
-        MAKE_ERROR(tefREVOKED_MANIFEST,            "The submitted manifest is for a revoked master key."),
 
         MAKE_ERROR(telLOCAL_ERROR,            "Local failure."),
         MAKE_ERROR(telBAD_DOMAIN,             "Domain too long."),
@@ -174,7 +172,6 @@ transResults()
         MAKE_ERROR(telIMPORT_VL_KEY_NOT_RECOGNISED, "Import vl key was not recognized."),
         MAKE_ERROR(telCAN_NOT_QUEUE_IMPORT,   "Import transaction was not able to be directly applied and cannot be queued."),
         MAKE_ERROR(telENV_RPC_FAILED,         "Unit test RPC failure."),
-        MAKE_ERROR(telMANIFEST_FEE_MISMATCH,  "Unsigned SetManifest fee is not, or cannot be confirmed as, canonical for this server's ledger fee settings."),
 
         MAKE_ERROR(temMALFORMED,                 "Malformed transaction."),
         MAKE_ERROR(temBAD_AMM_TOKENS,            "Malformed: Invalid LPTokens."),

src/libxrpl/protocol/TxFormats.cpp

@@ -48,7 +48,6 @@ TxFormats::TxFormats()
         {sfFirstLedgerSequence, soeOPTIONAL},
         {sfNetworkID, soeOPTIONAL},
         {sfHookParameters, soeOPTIONAL},
-        {sfHookName, soeOPTIONAL},
     };
 
 #pragma push_macro("UNWRAP")

src/libxrpl/protocol/tokens.cpp

@@ -545,7 +545,7 @@ b58_to_b256_be(std::string_view input, std::span<std::uint8_t> out)
     XRPL_ASSERT(
         num_b_58_10_coeffs <= b_58_10_coeff.size(),
         "ripple::b58_fast::detail::b58_to_b256_be : maximum coeff");
-    for (unsigned char const c : input.substr(0, partial_coeff_len))
+    for (auto c : input.substr(0, partial_coeff_len))
     {
         auto cur_val = ::ripple::alphabetReverse[c];
         if (cur_val < 0)
@@ -559,7 +559,7 @@ b58_to_b256_be(std::string_view input, std::span<std::uint8_t> out)
     {
         for (int j = 0; j < num_full_coeffs; ++j)
         {
-            unsigned char const c = input[partial_coeff_len + j * 10 + i];
+            auto c = input[partial_coeff_len + j * 10 + i];
             auto cur_val = ::ripple::alphabetReverse[c];
             if (cur_val < 0)
             {
@@ -580,12 +580,6 @@ b58_to_b256_be(std::string_view input, std::span<std::uint8_t> out)
     {
         std::uint64_t const c = b_58_10_coeff[i];
 
-        // Each digit is < 58, so at most 4 words are in use here and the
-        // span below always fits `result`. Guard the invariant anyway rather
-        // than letting a violation index past the end of the stack array.
-        if (cur_result_size >= result.size())
-            return Unexpected(TokenCodecErrc::inputTooLarge);
-
         {
             auto code = ripple::b58_fast::detail::inplace_bigint_mul(
                 std::span(&result[0], cur_result_size + 1), B_58_10);

src/libxrpl/server/Port.cpp

@@ -24,9 +24,6 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <sstream>
-#include <stdexcept>
-#include <string>
-#include <vector>
 
 namespace ripple {
 
@@ -208,7 +205,7 @@ parse_Port(ParsedPort& port, Section const& section, std::ostream& log)
         {
             try
             {
-                port.ip = boost::asio::ip::make_address(*optResult);
+                port.ip = boost::asio::ip::address::from_string(*optResult);
             }
             catch (std::exception const&)
             {

src/test/app/AMMClawback_test.cpp

@@ -32,12 +32,9 @@ class AMMClawback_test : public beast::unit_test::suite
         testcase("test invalid request");
         using namespace jtx;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
         // Test if holder does not exist.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(100000), gw, alice);
@@ -63,7 +60,7 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test if asset pair provided does not exist. This should
         // return terNO_AMM error.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(100000), gw, alice);
@@ -96,7 +93,7 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test if the issuer field and holder field is the same. This should
         // return temMALFORMED error.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(10000), gw, alice);
@@ -126,7 +123,7 @@ class AMMClawback_test : public beast::unit_test::suite
 
         // Test if the Asset field matches the Account field.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(10000), gw, alice);
@@ -158,7 +155,7 @@ class AMMClawback_test : public beast::unit_test::suite
 
         // Test if the Amount field matches the Asset field.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(10000), gw, alice);
@@ -191,7 +188,7 @@ class AMMClawback_test : public beast::unit_test::suite
 
         // Test if the Amount is invalid, which is less than zero.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(10000), gw, alice);
@@ -232,7 +229,7 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test if the issuer did not set asfAllowTrustLineClawback, AMMClawback
         // transaction is prohibited.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(10000), gw, alice);
@@ -257,7 +254,7 @@ class AMMClawback_test : public beast::unit_test::suite
 
         // Test invalid flag.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(10000), gw, alice);
@@ -285,7 +282,7 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test if tfClawTwoAssets is set when the two assets in the AMM pool
         // are not issued by the same issuer.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(10000), gw, alice);
@@ -316,7 +313,7 @@ class AMMClawback_test : public beast::unit_test::suite
 
         // Test clawing back XRP is being prohibited.
         {
-            Env env(*this, features);
+            Env env(*this);
             Account gw{"gateway"};
             Account alice{"alice"};
             env.fund(XRP(1000000), gw, alice);
@@ -2088,8 +2085,7 @@ class AMMClawback_test : public beast::unit_test::suite
     void
     run() override
     {
-        FeatureBitset const all{
-            jtx::supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{jtx::supported_amendments()};
 
         testInvalidRequest();
         testFeatureDisabled(all - featureAMMClawback);

src/test/app/AMMExtended_test.cpp

@@ -150,15 +150,12 @@ private:
 
             env.fund(XRP(20'000), alice, bob, carol, gw1, gw2);
             env.fund(XRP(20'000), dan);
-            env.close();
             env.trust(USD1(20'000), alice, bob, carol, dan);
             env.trust(USD2(1'000), alice, bob, carol, dan);
-            env.close();
 
             env(pay(gw1, dan, USD1(10'050)));
             env(pay(gw1, bob, USD1(50)));
             env(pay(gw2, bob, USD2(50)));
-            env.close();
 
             AMM ammDan(env, dan, XRP(10'000), USD1(10'050));
 
@@ -1406,8 +1403,7 @@ private:
     testOffers()
     {
         using namespace jtx;
-        FeatureBitset const all{
-            supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{supported_amendments()};
         testRmFundedOffer(all);
         testEnforceNoRipple(all);
         testFillModes(all);
@@ -1993,7 +1989,6 @@ private:
 
             env.fund(XRP(10'000), alice, carol, gw);
             env.fund(XRP(10'000), bob);
-            env.close();
             env.trust(USD(1'000), alice, bob, carol);
             env.trust(BTC(1'000), alice, bob, carol);
             env.trust(EUR(1'000), alice, bob, carol);
@@ -2807,11 +2802,8 @@ private:
         testcase("limitQuality");
         using namespace jtx;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
         {
-            Env env(*this, features);
+            Env env(*this);
 
             fund(env, gw, {alice, bob, carol}, XRP(10'000), {USD(2'000)});
 
@@ -2837,13 +2829,11 @@ private:
 
         using namespace jtx;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
         for (auto const withFix : {true, false})
         {
-            auto const feats =
-                withFix ? features : features - FeatureBitset{fix1781};
+            auto const feats = withFix
+                ? supported_amendments()
+                : supported_amendments() - FeatureBitset{fix1781};
 
             // Payment path starting with XRP
             Env env(*this, feats);
@@ -2871,7 +2861,7 @@ private:
         }
         {
             // Payment path ending with XRP
-            Env env(*this, features);
+            Env env(*this);
             // Note, if alice doesn't have default ripple, then pay fails
             // with tecPATH_DRY.
             fund(
@@ -2895,7 +2885,7 @@ private:
             // Payment where loop is formed in the middle of the path, not
             // on an endpoint
             auto const JPY = gw["JPY"];
-            Env env(*this, features);
+            Env env(*this);
             // Note, if alice doesn't have default ripple, then pay fails
             // with tecPATH_DRY.
             fund(
@@ -3123,10 +3113,7 @@ private:
 
         using namespace jtx;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
-        Env env(*this, features);
+        Env env(*this);
 
         fund(env, gw, {alice, bob, carol}, XRP(10'000));
         env.trust(USD(1'000), alice, bob, carol);
@@ -3645,7 +3632,7 @@ private:
             USD(10'000),
             false,
             0,
-            ammCrtFee(env).drops() + 2 * env.current()->fees().base.drops(),
+            ammCrtFee(env).drops(),
             std::nullopt,
             std::nullopt,
             ms,
@@ -3841,8 +3828,7 @@ private:
     testFlow()
     {
         using namespace jtx;
-        FeatureBitset const all{
-            supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{supported_amendments()};
         FeatureBitset const ownerPaysFee{featureOwnerPaysFee};
 
         testFalseDry(all);
@@ -3858,8 +3844,7 @@ private:
     testCrossingLimits()
     {
         using namespace jtx;
-        FeatureBitset const all{
-            supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{supported_amendments()};
         testStepLimit(all);
     }
 
@@ -3867,16 +3852,14 @@ private:
     testDeliverMin()
     {
         using namespace jtx;
-        FeatureBitset const all{
-            supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{supported_amendments()};
         test_convert_all_of_an_asset(all);
     }
 
     void
     testDepositAuth()
     {
-        auto const supported{
-            jtx::supported_amendments() | featureAMM | featureAMMClawback};
+        auto const supported{jtx::supported_amendments()};
         testPayment(supported - featureDepositPreauth);
         testPayment(supported);
         testPayIOU();
@@ -3886,8 +3869,7 @@ private:
     testFreeze()
     {
         using namespace test::jtx;
-        auto const sa =
-            supported_amendments() | featureAMM | featureAMMClawback;
+        auto const sa = supported_amendments();
         testRippleState(sa);
         testGlobalFreeze(sa);
         testOffersWhenFrozen(sa);
@@ -3897,8 +3879,7 @@ private:
     testMultisign()
     {
         using namespace jtx;
-        auto const all =
-            supported_amendments() | featureAMM | featureAMMClawback;
+        auto const all = supported_amendments();
 
         testTxMultisign(
             all - featureMultiSignReserve - featureExpandedSignerList);
@@ -3910,8 +3891,7 @@ private:
     testPayStrand()
     {
         using namespace jtx;
-        auto const all =
-            supported_amendments() | featureAMM | featureAMMClawback;
+        auto const all = supported_amendments();
 
         testToStrand(all);
         testRIPD1373(all);

src/test/app/AMM_test.cpp

@@ -56,9 +56,6 @@ private:
 
         using namespace jtx;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
         // XRP to IOU
         testAMM([&](AMM& ammAlice, Env&) {
             BEAST_EXPECT(ammAlice.expectBalances(
@@ -75,7 +72,7 @@ private:
 
         // IOU to IOU + transfer fee
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(20'000), BTC(0.5)}, Fund::All);
             env(rate(gw, 1.25));
             env.close();
@@ -89,7 +86,7 @@ private:
 
         // Require authorization is set, account is authorized
         {
-            Env env{*this, features};
+            Env env{*this};
             env.fund(XRP(30'000), gw, alice);
             env.close();
             env(fset(gw, asfRequireAuth));
@@ -103,7 +100,7 @@ private:
 
         // Cleared global freeze
         {
-            Env env{*this, features};
+            Env env{*this};
             env.fund(XRP(30'000), gw, alice);
             env.close();
             env.trust(USD(30'000), alice);
@@ -144,12 +141,9 @@ private:
 
         using namespace jtx;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
         // Can't have both XRP tokens
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
             AMM ammAlice(
                 env, alice, XRP(10'000), XRP(10'000), ter(temBAD_AMM_TOKENS));
@@ -158,7 +152,7 @@ private:
 
         // Can't have both tokens the same IOU
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
             AMM ammAlice(
                 env, alice, USD(10'000), USD(10'000), ter(temBAD_AMM_TOKENS));
@@ -167,7 +161,7 @@ private:
 
         // Can't have zero or negative amounts
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
             AMM ammAlice(env, alice, XRP(0), USD(10'000), ter(temBAD_AMOUNT));
             BEAST_EXPECT(!ammAlice.ammExists());
@@ -183,7 +177,7 @@ private:
 
         // Bad currency
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
             AMM ammAlice(
                 env, alice, XRP(10'000), BAD(10'000), ter(temBAD_CURRENCY));
@@ -192,7 +186,7 @@ private:
 
         // Insufficient IOU balance
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
             AMM ammAlice(
                 env, alice, XRP(10'000), USD(40'000), ter(tecUNFUNDED_AMM));
@@ -201,7 +195,7 @@ private:
 
         // Insufficient XRP balance
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
             AMM ammAlice(
                 env, alice, XRP(40'000), USD(10'000), ter(tecUNFUNDED_AMM));
@@ -210,7 +204,7 @@ private:
 
         // Invalid trading fee
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
             AMM ammAlice(
                 env,
@@ -235,7 +229,7 @@ private:
 
         // Invalid flags
         {
-            Env env{*this, features};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
             AMM ammAlice(
                 env,
@@ -254,7 +248,7 @@ private:
 
         // Invalid Account
         {
-            Env env{*this, features};
+            Env env{*this};
             Account bad("bad");
             env.memoize(bad);
             AMM ammAlice(
@@ -274,7 +268,7 @@ private:
 
         // Require authorization is set
         {
-            Env env{*this, features};
+            Env env{*this};
             env.fund(XRP(30'000), gw, alice);
             env.close();
             env(fset(gw, asfRequireAuth));
@@ -287,7 +281,7 @@ private:
 
         // Globally frozen
         {
-            Env env{*this, features};
+            Env env{*this};
             env.fund(XRP(30'000), gw, alice);
             env.close();
             env(fset(gw, asfGlobalFreeze));
@@ -300,7 +294,7 @@ private:
 
         // Individually frozen
         {
-            Env env{*this, features};
+            Env env{*this};
             env.fund(XRP(30'000), gw, alice);
             env.close();
             env(trust(gw, alice["USD"](30'000)));
@@ -313,7 +307,7 @@ private:
 
         // Insufficient reserve, XRP/IOU
         {
-            Env env(*this, features);
+            Env env(*this);
             auto const starting_xrp =
                 XRP(1'000) + reserve(env, 3) + env.current()->fees().base * 4;
             env.fund(starting_xrp, gw);
@@ -330,7 +324,7 @@ private:
 
         // Insufficient reserve, IOU/IOU
         {
-            Env env(*this, features);
+            Env env(*this);
             auto const starting_xrp =
                 reserve(env, 4) + env.current()->fees().base * 5;
             env.fund(starting_xrp, gw);
@@ -349,7 +343,7 @@ private:
 
         // Insufficient fee
         {
-            Env env(*this, features);
+            Env env(*this);
             fund(env, gw, {alice}, XRP(2'000), {USD(2'000), EUR(2'000)});
             AMM ammAlice(
                 env,
@@ -400,7 +394,7 @@ private:
 
         // Issuer has DefaultRipple disabled
         {
-            Env env(*this, features);
+            Env env(*this);
             env.fund(XRP(30'000), gw);
             env(fclear(gw, asfDefaultRipple));
             AMM ammGw(env, gw, XRP(10'000), USD(10'000), ter(terNO_RIPPLE));
@@ -1125,7 +1119,7 @@ private:
 
         // Insufficient reserve, XRP/IOU
         {
-            Env env(*this, features);
+            Env env(*this);
             auto const starting_xrp =
                 reserve(env, 4) + env.current()->fees().base * 4;
             env.fund(XRP(10'000), gw);
@@ -1160,7 +1154,7 @@ private:
 
         // Insufficient reserve, IOU/IOU
         {
-            Env env(*this, features);
+            Env env(*this);
             auto const starting_xrp =
                 reserve(env, 4) + env.current()->fees().base * 4;
             env.fund(XRP(10'000), gw);
@@ -1362,8 +1356,7 @@ private:
         testcase("Deposit");
 
         using namespace jtx;
-        auto const all =
-            supported_amendments() | featureAMM | featureAMMClawback;
+        auto const all = supported_amendments();
 
         // Equal deposit: 1000000 tokens, 10% of the current pool
         testAMM([&](AMM& ammAlice, Env& env) {
@@ -1523,7 +1516,7 @@ private:
 
         // IOU to IOU + transfer fee
         {
-            Env env{*this, all};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(20'000), BTC(0.5)}, Fund::All);
             env(rate(gw, 1.25));
             env.close();
@@ -1664,8 +1657,7 @@ private:
         testcase("Invalid Withdraw");
 
         using namespace jtx;
-        auto const all =
-            supported_amendments() | featureAMM | featureAMMClawback;
+        auto const all = supported_amendments();
 
         testAMM(
             [&](AMM& ammAlice, Env& env) {
@@ -1688,7 +1680,7 @@ private:
             {{XRP(99), USD(99)}});
 
         {
-            Env env{*this, all};
+            Env env{*this};
             env.fund(XRP(30'000), gw, alice, bob);
             env.close();
             env(fset(gw, asfRequireAuth));
@@ -2236,8 +2228,7 @@ private:
         testcase("Withdraw");
 
         using namespace jtx;
-        auto const all =
-            supported_amendments() | featureAMM | featureAMMClawback;
+        auto const all = supported_amendments();
 
         // Equal withdrawal by Carol: 1000000 of tokens, 10% of the current
         // pool
@@ -2451,7 +2442,7 @@ private:
 
         // IOU to IOU + transfer fee
         {
-            Env env{*this, all};
+            Env env{*this};
             fund(env, gw, {alice}, {USD(20'000), BTC(0.5)}, Fund::All);
             env(rate(gw, 1.25));
             env.close();
@@ -2614,8 +2605,7 @@ private:
     {
         testcase("Fee Vote");
         using namespace jtx;
-        auto const all =
-            supported_amendments() | featureAMM | featureAMMClawback;
+        auto const all = supported_amendments();
 
         // One vote sets fee to 1%.
         testAMM([&](AMM& ammAlice, Env& env) {
@@ -2733,12 +2723,9 @@ private:
         using namespace jtx;
         using namespace std::chrono;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
         // burn all the LPTokens through a AMMBid transaction
         {
-            Env env(*this, features);
+            Env env(*this);
             fund(env, gw, {alice}, XRP(2'000), {USD(2'000)});
             AMM amm(env, gw, XRP(1'000), USD(1'000), false, 1'000);
 
@@ -2757,7 +2744,7 @@ private:
 
         // burn all the LPTokens through a AMMBid transaction
         {
-            Env env(*this, features);
+            Env env(*this);
             fund(env, gw, {alice}, XRP(2'000), {USD(2'000)});
             AMM amm(env, gw, XRP(1'000), USD(1'000), false, 1'000);
 
@@ -2935,7 +2922,7 @@ private:
 
         // Bid all tokens, still own the slot
         {
-            Env env(*this, features);
+            Env env(*this);
             fund(env, gw, {alice, bob}, XRP(1'000), {USD(1'000)});
             AMM amm(env, gw, XRP(10), USD(1'000));
             auto const lpIssue = amm.lptIssue();
@@ -3374,15 +3361,12 @@ private:
         using namespace std::chrono;
         using namespace std::literals::chrono_literals;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
         // Can't pay into AMM account.
         // Can't pay out since there is no keys
         for (auto const& acct : {gw, alice})
         {
             {
-                Env env(*this, features);
+                Env env(*this);
                 fund(env, gw, {alice, carol}, XRP(1'000), {USD(100)});
                 // XRP balance is below reserve
                 AMM ammAlice(env, acct, XRP(10), USD(10));
@@ -3397,7 +3381,7 @@ private:
                     ter(tecNO_PERMISSION));
             }
             {
-                Env env(*this, features);
+                Env env(*this);
                 fund(env, gw, {alice, carol}, XRP(10'000'000), {USD(10'000)});
                 // XRP balance is above reserve
                 AMM ammAlice(env, acct, XRP(1'000'000), USD(100));
@@ -4433,8 +4417,7 @@ private:
     {
         testcase("Amendment");
         using namespace jtx;
-        FeatureBitset const all{
-            supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{supported_amendments()};
         FeatureBitset const noAMM{all - featureAMM};
         FeatureBitset const noNumber{all - fixUniversalNumber};
         FeatureBitset const noAMMAndNumber{
@@ -4484,9 +4467,6 @@ private:
         testcase("Rippling");
         using namespace jtx;
 
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-
         // Rippling via AMM fails because AMM trust line has 0 limit.
         // Set up two issuers, A and B. Have each issue a token called TST.
         // Have another account C hold TST from both issuers,
@@ -4498,7 +4478,7 @@ private:
         //   to shift at a 1:1 rate with no fee applied has it not been
         //   for 0 limit.
         {
-            Env env(*this, features);
+            Env env(*this);
             auto const A = Account("A");
             auto const B = Account("B");
             auto const TSTA = A["TST"];
@@ -5004,8 +4984,8 @@ private:
                     alice,
                     STAmount{USD, UINT64_C(30'000'0000000003), -10}));
                 // alice XRP balance is 30,000initial - 50 ammcreate fee -
-                // 10drops ammcreate base fee - 10drops fee
-                BEAST_EXPECT(accountBalance(env, alice) == "29949999980");
+                // 10drops fee
+                BEAST_EXPECT(accountBalance(env, alice) == "29949999990");
             },
             std::nullopt,
             0,
@@ -5081,7 +5061,7 @@ private:
                     (xrpBalance + drops(5)).getText());
                 BEAST_EXPECT(
                     accountBalance(env, alice) ==
-                    std::to_string(29'950'000'000 - 2 * baseFee + 80));
+                    std::to_string(29'950'000'000 - baseFee + 80));
             },
             std::nullopt,
             0,
@@ -5095,8 +5075,7 @@ private:
         testcase("Auto Delete");
 
         using namespace jtx;
-        FeatureBitset const all{
-            supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{supported_amendments()};
 
         {
             Env env(
@@ -5208,9 +5187,7 @@ private:
     {
         testcase("Clawback");
         using namespace jtx;
-        auto const features =
-            supported_amendments() | featureAMM | featureAMMClawback;
-        Env env(*this, features);
+        Env env(*this);
         env.fund(XRP(2'000), gw);
         env.fund(XRP(2'000), alice);
         AMM amm(env, gw, XRP(1'000), USD(1'000));
@@ -5609,8 +5586,7 @@ private:
     {
         testcase("Fix Default Inner Object");
         using namespace jtx;
-        FeatureBitset const all{
-            supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{supported_amendments()};
 
         auto test = [&](FeatureBitset features,
                         TER const& err1,
@@ -6329,7 +6305,7 @@ private:
             {{xrpPool, iouPool}},
             889,
             std::nullopt,
-            {jtx::supported_amendments() | featureAMM | featureAMMClawback});
+            {jtx::supported_amendments()});
     }
 
     void
@@ -7145,8 +7121,7 @@ private:
     void
     run() override
     {
-        FeatureBitset const all{
-            jtx::supported_amendments() | featureAMM | featureAMMClawback};
+        FeatureBitset const all{jtx::supported_amendments()};
         testInvalidInstance();
         testInstanceCreate();
         testInvalidDeposit(all);

src/test/app/BaseFee_test.cpp

@@ -88,7 +88,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = fset(account, asfTshCollect);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -110,7 +112,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = acctdelete(account, bene);
 
         // verify hooks fee
-        testRPCCall(env, tx, "200000");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "200000" : "200000";
+        testRPCCall(env, tx, feeResult);
     }
 
     static uint256
@@ -138,7 +142,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = check::cancel(account, checkId);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -161,7 +167,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = check::cash(dest, checkId, XRP(100));
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -183,7 +191,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = check::create(account, dest, XRP(100));
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -204,7 +214,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = reward::claim(account);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -226,7 +238,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = deposit::auth(account, authed);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -248,7 +262,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = cancel(account, account, seq1);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -270,7 +286,8 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = escrow(account, dest, XRP(10));
 
         // verify hooks fee
-        std::string const feeResult = "16";
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
         testRPCCall(env, tx, feeResult);
     }
 
@@ -293,7 +310,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = finish(account, account, seq1);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -315,7 +334,9 @@ class BaseFee_test : public beast::unit_test::suite
             account, import::loadXpop(ImportTCAccountSet::w_seed));
 
         // verify hooks fee
-        testRPCCall(env, tx, "106");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "106" : "100";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -336,7 +357,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = invoke::invoke(account);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "16";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -358,7 +381,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = offer_cancel(account, offerSeq);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -381,7 +406,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = offer(account, USD(1000), XRP(1000));
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -403,7 +430,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = pay(account, dest, XRP(1));
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     static uint256
@@ -439,7 +468,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = paychan::claim(account, chan, reqBal, authAmt);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -463,7 +494,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = paychan::create(account, dest, XRP(10), settleDelay, pk);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -486,7 +519,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = paychan::fund(account, chan, XRP(1));
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -517,7 +552,9 @@ class BaseFee_test : public beast::unit_test::suite
         hookParams[jss::HookParameter][jss::HookParameterValue] = "DEADBEEF";
 
         // verify hooks fee
-        testRPCCall(env, tx, "73022");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "73022" : "73016";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -539,7 +576,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = regkey(account, dest);
 
         // verify hooks fee
-        testRPCCall(env, tx, "0");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "0" : "0";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -562,7 +601,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = signers(account, 2, {{signer1, 1}, {signer2, 1}});
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -583,7 +624,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = ticket::create(account, 2);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -606,7 +649,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = trust(account, USD(1000));
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -630,7 +675,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = uritoken::burn(issuer, hexid);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -655,7 +702,9 @@ class BaseFee_test : public beast::unit_test::suite
         tx[jss::Amount] = "1000000";
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -679,7 +728,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = uritoken::cancel(issuer, hexid);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -706,7 +757,8 @@ class BaseFee_test : public beast::unit_test::suite
         tx[jss::Amount] = "1000000";
 
         // verify hooks fee
-        std::string const feeResult = "16";
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
         testRPCCall(env, tx, feeResult);
     }
 
@@ -729,7 +781,9 @@ class BaseFee_test : public beast::unit_test::suite
         auto tx = uritoken::mint(account, uri);
 
         // verify hooks fee
-        testRPCCall(env, tx, "16");
+        std::string const feeResult =
+            env.current()->rules().enabled(fixXahauV1) ? "16" : "10";
+        testRPCCall(env, tx, feeResult);
     }
 
     void
@@ -773,6 +827,7 @@ public:
         using namespace test::jtx;
         auto const sa = supported_amendments();
         testWithFeats(sa);
+        testWithFeats(sa - fixXahauV1);
     }
 };
 

src/test/app/ClaimReward_test.cpp

@@ -18,7 +18,6 @@
 //==============================================================================
 
 #include <test/jtx.h>
-#include <test/jtx/AMM.h>
 #include <xrpld/app/ledger/LedgerMaster.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/jss.h>
@@ -27,14 +26,6 @@ namespace ripple {
 namespace test {
 struct ClaimReward_test : public beast::unit_test::suite
 {
-private:
-    // helper
-    void static overrideFlag(Json::Value& jv)
-    {
-        jv[jss::Flags] = hsfOVERRIDE;
-    }
-
-public:
     bool
     expectRewards(
         jtx::Env const& env,
@@ -68,52 +59,6 @@ public:
         return true;
     }
 
-    bool
-    expectRewardsIOU(
-        jtx::Env const& env,
-        jtx::Account const& acct,
-        jtx::IOU const& iou,
-        std::uint32_t ledgerFirst,
-        std::uint32_t ledgerLast,
-        STAmount accumulator,
-        std::uint32_t time)
-    {
-        auto const sle = env.le(keylet::line(acct, iou.account, iou.currency));
-        BEAST_EXPECT(!!sle);
-        auto const& sfRewardField =
-            std::minmax(acct.id(), iou.account.id()).first == acct.id()
-            ? sfLowReward
-            : sfHighReward;
-
-        if (!sle->isFieldPresent(sfRewardField))
-            return false;
-
-        auto const& reward =
-            static_cast<STObject const&>(sle->peekAtField(sfRewardField));
-
-        if (!reward.isFieldPresent(sfRewardLgrFirst) ||
-            reward.getFieldU32(sfRewardLgrFirst) != ledgerFirst)
-        {
-            return false;
-        }
-        if (!reward.isFieldPresent(sfRewardLgrLast) ||
-            reward.getFieldU32(sfRewardLgrLast) != ledgerLast)
-        {
-            return false;
-        }
-        if (!reward.isFieldPresent(sfTrustLineRewardAccumulator) ||
-            reward.getFieldAmount(sfTrustLineRewardAccumulator) != accumulator)
-        {
-            return false;
-        }
-        if (!reward.isFieldPresent(sfRewardTime) ||
-            reward.getFieldU32(sfRewardTime) != time)
-        {
-            return false;
-        }
-        return true;
-    }
-
     bool
     expectNoRewards(jtx::Env const& env, jtx::Account const& acct)
     {
@@ -137,24 +82,6 @@ public:
         return true;
     }
 
-    bool
-    expectNoRewardsIOU(
-        jtx::Env const& env,
-        jtx::Account const& acct,
-        jtx::IOU const& iou)
-    {
-        auto const sle = env.le(keylet::line(acct, iou.account, iou.currency));
-        BEAST_EXPECT(!!sle);
-        auto const& sfRewardField =
-            std::minmax(acct.id(), iou.account.id()).first == acct.id()
-            ? sfLowReward
-            : sfHighReward;
-
-        if (sle->isFieldPresent(sfRewardField))
-            return false;
-        return true;
-    }
-
     void
     testEnabled(FeatureBitset features)
     {
@@ -164,7 +91,7 @@ public:
 
         // setup env
         auto const alice = Account("alice");
-        auto const issuer = Account::master;
+        auto const issuer = Account("issuer");
 
         for (bool const withClaimReward : {false, true})
         {
@@ -174,11 +101,7 @@ public:
                 withClaimReward ? features : features - featureBalanceRewards;
             Env env{*this, amend};
 
-            env.fund(XRP(1000), alice);
-            env.close();
-
-            env(hook(issuer, {{hso(jtx::genesis::AcceptHook)}}, 0),
-                fee(XRP(1)));
+            env.fund(XRP(1000), alice, issuer);
             env.close();
 
             auto const txResult =
@@ -195,10 +118,7 @@ public:
                     .count();
 
             // CLAIM
-            env(reward::claim(alice),
-                reward::issuer(issuer),
-                fee(XRP(1)),
-                txResult);
+            env(reward::claim(alice), reward::issuer(issuer), txResult);
             env.close();
 
             if (withClaimReward)
@@ -274,19 +194,14 @@ public:
                 Env env{*this, amend};
 
                 auto const alice = Account("alice");
-                auto const issuer = Account::master;
+                auto const issuer = Account("issuer");
 
-                env.fund(XRP(1000), alice);
-                env.close();
-
-                env(hook(issuer, {{hso(jtx::genesis::AcceptHook)}}, 0),
-                    fee(XRP(1)));
+                env.fund(XRP(1000), alice, issuer);
                 env.close();
 
                 auto tx = reward::claim(alice);
                 env(tx,
                     reward::issuer(issuer),
-                    fee(XRP(1)),
                     txflags(tfFullyCanonicalSig),
                     withFixFlags ? ter(tesSUCCESS) : ter(temINVALID_FLAG));
                 env.close();
@@ -305,105 +220,6 @@ public:
             env(reward::claim(alice), reward::issuer(alice), ter(temMALFORMED));
             env.close();
         }
-
-        // featureIOURewardClaim
-
-        // temDISABLED
-        // featureIOURewardClaim amendment is disabled
-        {
-            test::jtx::Env env{
-                *this,
-                network::makeNetworkConfig(21337),
-                features - featureIOURewardClaim};
-
-            auto const alice = Account("alice");
-            auto const bob = Account("bob");
-            auto const gw = Account("gw");
-            env.fund(XRP(1000), alice, bob, gw);
-            env.close();
-
-            jtx::IOU const USD = gw["USD"];
-
-            env(reward::claim(alice),
-                reward::issuer(bob),
-                reward::claimCurrency(USD),
-                ter(temDISABLED));
-            env.close();
-        }
-
-        // temMALFORMED
-        // ClaimCurrency.account cannot be the source account.
-        {
-            test::jtx::Env env{*this, network::makeNetworkConfig(21337)};
-
-            auto const alice = Account("alice");
-            auto const bob = Account("bob");
-            env.fund(XRP(1000), alice);
-            env.close();
-
-            jtx::IOU const USD = alice["USD"];
-
-            env(reward::claim(alice),
-                reward::issuer(bob),
-                reward::claimCurrency(USD),
-                ter(temMALFORMED));
-            env.close();
-        }
-
-        // temMALFORMED
-        // Issuer cannot be Genesis account if ClaimCurrency is set.
-        {
-            test::jtx::Env env{*this, network::makeNetworkConfig(21337)};
-
-            auto const alice = Account("alice");
-            auto const gw = Account("gw");
-            env.fund(XRP(1000), alice, gw);
-            env.close();
-
-            jtx::IOU const USD = gw["USD"];
-
-            env(reward::claim(alice),
-                reward::issuer(Account::master),
-                reward::claimCurrency(USD),
-                ter(temBAD_ISSUER));
-        }
-
-        // MPT
-        {
-            // tested in testMPTInvalidInTx() at MPToken_test.cpp
-        }
-
-        // XAH RewardClaim: Issuer must be the Genesis account if
-        // featureXahauGenesis and featureIOURewardClaim are enabled.
-        for (bool const withIOURewardClaim : {false, true})
-        {
-            auto const amend = withIOURewardClaim
-                ? features
-                : features - featureIOURewardClaim;
-
-            auto const alice = Account("alice");
-            auto const badIssuer = Account("gw");
-            auto const issuer = Account::master;
-            auto const USD = badIssuer["USD"];
-
-            Env env{*this, amend};
-            env.fund(XRP(1000), alice, badIssuer);
-            env.close();
-
-            env(hook(issuer, {{hso(jtx::genesis::AcceptHook)}}, 0),
-                fee(XRP(1)));
-            env.close();
-
-            env(reward::claim(alice),
-                reward::issuer(badIssuer),
-                fee(XRP(1)),
-                withIOURewardClaim ? ter(temBAD_ISSUER) : ter(tesSUCCESS));
-
-            env(reward::claim(alice),
-                reward::issuer(issuer),
-                fee(XRP(1)),
-                ter(tesSUCCESS));
-        }
     }
 
     void
@@ -427,7 +243,6 @@ public:
             auto const alice = Account("alice");
             auto const issuer = Account("issuer");
             env.memoize(alice);
-            auto USD = issuer["USD"];
 
             env.fund(XRP(1000), issuer);
             env.close();
@@ -435,10 +250,7 @@ public:
             auto tx = reward::claim(alice);
             tx[jss::Sequence] = 0;
             tx[jss::Fee] = 10;
-            env(tx,
-                reward::issuer(issuer),
-                reward::claimCurrency(USD),
-                ter(terNO_ACCOUNT));
+            env(tx, reward::issuer(issuer), ter(terNO_ACCOUNT));
             env.close();
         }
 
@@ -448,9 +260,9 @@ public:
             test::jtx::Env env{*this, network::makeNetworkConfig(21337)};
 
             auto const alice = Account("alice");
-            auto const issuer = Account::master;
+            auto const issuer = Account("issuer");
 
-            env.fund(XRP(1000), alice);
+            env.fund(XRP(1000), alice, issuer);
             env.close();
 
             env(reward::claim(alice),
@@ -481,210 +293,13 @@ public:
             auto const issuer = Account("issuer");
             env.memoize(issuer);
 
-            auto USD = issuer["USD"];
-
             env.fund(XRP(1000), alice);
             env.close();
 
             auto tx = reward::claim(alice);
-            env(tx,
-                reward::issuer(issuer),
-                reward::claimCurrency(USD),
-                ter(tecNO_ISSUER));
+            env(tx, reward::issuer(issuer), ter(tecNO_ISSUER));
             env.close();
         }
-
-        // tecNO_PERMISSION
-        // issuer is an AMM account
-        {
-            test::jtx::Env env{
-                *this,
-                network::makeNetworkConfig(21337),
-                features | featureAMM};
-
-            auto const alice = Account("alice");
-            auto const issuer = Account("issuer");
-            auto const USD = issuer["USD"];
-
-            env.fund(XRP(1000), alice, issuer);
-            env.close();
-
-            AMM amm(env, issuer, XRP(100), USD(100));
-
-            BEAST_EXPECT(amm.ammExists());
-
-            env(reward::claim(alice),
-                reward::issuer(amm.ammAccount()),
-                reward::claimCurrency(USD),
-                ter(tecNO_PERMISSION));
-            env.close();
-        }
-
-        // tecNO_TARGET
-        // no claim reward hook
-        {
-            Env env{*this};
-
-            auto const alice = Account("alice");
-            auto const issuer = Account::master;
-
-            env.fund(XRP(1000), alice);
-            env.close();
-
-            // Doesn't have hook
-            {
-                env(reward::claim(alice),
-                    reward::issuer(issuer),
-                    ter(tecNO_TARGET));
-                env.close();
-            }
-            // Invalid HookOn
-            {
-                auto hookObj = hso(jtx::genesis::AcceptHook, overrideFlag);
-                hookObj[jss::HookOn] = to_string(UINT256_BIT[ttCLAIM_REWARD]);
-                env(hook(issuer, {{hookObj}}, 0), fee(XRP(1)));
-                env.close();
-
-                env(reward::claim(alice),
-                    reward::issuer(issuer),
-                    ter(tecNO_TARGET));
-                env.close();
-            }
-            // Invalid IncomingHookOn
-            {
-                auto hookObj = hso(jtx::genesis::AcceptHook, overrideFlag);
-                hookObj.removeMember(jss::HookOn);
-                hookObj[jss::HookOnIncoming] =
-                    to_string(UINT256_BIT[ttCLAIM_REWARD]);
-                hookObj[jss::HookOnOutgoing] = to_string(uint256{});
-                env(hook(issuer, {{hookObj}}, 0), fee(XRP(1)));
-                env.close();
-
-                env(reward::claim(alice),
-                    reward::issuer(issuer),
-                    ter(tecNO_TARGET));
-                env.close();
-            }
-            // Invalid HookName
-            {
-                auto hookObj = hso(jtx::genesis::AcceptHook, overrideFlag);
-                hookObj[jss::HookOn] = to_string(~UINT256_BIT[ttCLAIM_REWARD]);
-                hookObj[jss::HookName] = "4142434445";
-                env(hook(issuer, {{hookObj}}, 0), fee(XRP(1)));
-                env.close();
-
-                env(reward::claim(alice),
-                    reward::issuer(issuer),
-                    ter(tecNO_TARGET));
-                env.close();
-            }
-            // Vaild HookOn
-            {
-                auto hookObj = hso(jtx::genesis::AcceptHook, overrideFlag);
-                hookObj[jss::HookOn] = to_string(~UINT256_BIT[ttCLAIM_REWARD]);
-                env(hook(issuer, {{hookObj}}, 0), fee(XRP(1)));
-                env.close();
-
-                env(reward::claim(alice),
-                    reward::issuer(issuer),
-                    fee(XRP(1)),
-                    ter(tesSUCCESS));
-            }
-            // Vaild IncomingHookOn
-            {
-                auto hookObj = hso(jtx::genesis::AcceptHook, overrideFlag);
-                hookObj.removeMember(jss::HookOn);
-                hookObj[jss::HookOnIncoming] =
-                    to_string(~UINT256_BIT[ttCLAIM_REWARD]);
-                hookObj[jss::HookOnOutgoing] = to_string(uint256{});
-                env(hook(issuer, {{hookObj}}, 0), fee(XRP(1)));
-                env.close();
-
-                env(reward::claim(alice),
-                    reward::issuer(issuer),
-                    fee(XRP(1)),
-                    ter(tesSUCCESS));
-            }
-            // Invalid Hooks Array
-            {
-                auto hookObj = hso(jtx::genesis::AcceptHook, overrideFlag);
-                hookObj[jss::HookOn] = to_string(UINT256_BIT[ttCLAIM_REWARD]);
-                env(hook(
-                        issuer,
-                        {{
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                        }},
-                        0),
-                    fee(XRP(1)));
-                env.close();
-
-                env(reward::claim(alice),
-                    reward::issuer(issuer),
-                    fee(XRP(1)),
-                    ter(tecNO_TARGET));
-            }
-            // Vaild Hooks Array
-            {
-                auto hookObj = hso(jtx::genesis::AcceptHook, overrideFlag);
-                hookObj[jss::HookOn] = to_string(UINT256_BIT[ttCLAIM_REWARD]);
-                auto hookObj2 = hso(jtx::genesis::AcceptHook, overrideFlag);
-                hookObj2[jss::HookOn] = to_string(~UINT256_BIT[ttCLAIM_REWARD]);
-                env(hook(
-                        issuer,
-                        {{
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj,
-                            hookObj2,
-                        }},
-                        0),
-                    fee(XRP(1)));
-                env.close();
-
-                env(reward::claim(alice),
-                    reward::issuer(issuer),
-                    fee(XRP(1)),
-                    ter(tesSUCCESS));
-            }
-        }
-
-        // tecNO_LINE
-        // trustline does not exist.
-        {
-            test::jtx::Env env{*this, network::makeNetworkConfig(21337)};
-
-            auto const alice = Account("alice");
-
-            auto const gw = Account("gw");
-            env.fund(XRP(1000), alice, gw);
-            env.close();
-
-            env(hook(gw, {{hso(jtx::genesis::AcceptHook)}}, 0), fee(XRP(1)));
-            env.close();
-
-            jtx::IOU const USD = gw["USD"];
-
-            env(reward::claim(alice),
-                reward::issuer(gw),
-                reward::claimCurrency(USD),
-                fee(XRP(1)),
-                ter(tecNO_LINE));
-        }
     }
 
     void
@@ -697,17 +312,9 @@ public:
         test::jtx::Env env{*this, network::makeNetworkConfig(21337)};
 
         auto const alice = Account("alice");
-        auto const bob = Account("bob");
-        auto const gw = Account("gw");
         auto const issuer = Account("issuer");
 
-        env.fund(XRP(1000), alice, bob, gw, issuer);
-        env.close();
-
-        env(hook(issuer, {{hso(jtx::genesis::AcceptHook)}}, 0), fee(XRP(1)));
-        env.close();
-        env(hook(Account::master, {{hso(jtx::genesis::AcceptHook)}}, 0),
-            fee(XRP(1)));
+        env.fund(XRP(1000), alice, issuer);
         env.close();
 
         // test claim rewards - no opt out
@@ -722,7 +329,7 @@ public:
                 .count();
 
         auto tx = reward::claim(alice);
-        env(tx, reward::issuer(Account::master), fee(XRP(1)), ter(tesSUCCESS));
+        env(tx, reward::issuer(issuer), ter(tesSUCCESS));
         env.close();
 
         BEAST_EXPECT(
@@ -735,51 +342,6 @@ public:
         env.close();
 
         BEAST_EXPECT(expectNoRewards(env, alice) == true);
-
-        // test iou claim rewards
-        {
-            // set trustline
-            env(trust(bob, gw["USD"](10000)));
-            env.close();
-
-            // opt in
-            auto const currentLedger = env.current()->seq();
-            auto const currentTime =
-                std::chrono::duration_cast<std::chrono::seconds>(
-                    env.app()
-                        .getLedgerMaster()
-                        .getValidatedLedger()
-                        ->info()
-                        .parentCloseTime.time_since_epoch())
-                    .count();
-
-            auto tx = reward::claim(bob);
-            env(tx,
-                reward::issuer(issuer),
-                reward::claimCurrency(gw["USD"]),
-                fee(XRP(1)),
-                ter(tesSUCCESS));
-            env.close();
-
-            BEAST_EXPECT(
-                expectRewardsIOU(
-                    env,
-                    bob,
-                    gw["USD"],
-                    currentLedger,
-                    currentLedger,
-                    gw["USD"](0),
-                    currentTime) == true);
-
-            // opt out
-            env(reward::claim(bob),
-                reward::claimCurrency(gw["USD"]),
-                txflags(tfOptOut),
-                ter(tesSUCCESS));
-            env.close();
-
-            BEAST_EXPECT(expectNoRewardsIOU(env, bob, gw["USD"]) == true);
-        }
     }
 
     void
@@ -790,20 +352,16 @@ public:
         using namespace std::literals::chrono_literals;
         Env env{*this, features};
         auto const alice = Account("alice");
-        auto const issuer = Account::master;
-        env.fund(XRP(10000), alice);
+        auto const issuer = Account("issuer");
+        env.fund(XRP(10000), alice, issuer);
         std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
         env(ticket::create(alice, 10));
         std::uint32_t const aliceSeq{env.seq(alice)};
         env.require(owners(alice, 10));
 
-        env(hook(issuer, {{hso(jtx::genesis::AcceptHook)}}, 0), fee(XRP(1)));
-        env.close();
-
         env(reward::claim(alice),
             reward::issuer(issuer),
             ticket::use(aliceTicketSeq++),
-            fee(XRP(1)),
             ter(tesSUCCESS));
 
         env.require(tickets(alice, env.seq(alice) - aliceTicketSeq));
@@ -811,317 +369,6 @@ public:
         env.require(owners(alice, 9));
     }
 
-    void
-    testBalanceChanges(FeatureBitset features)
-    {
-        testcase("balance changes");
-        using namespace jtx;
-        using namespace std::literals::chrono_literals;
-
-        auto const getCurrentTime = [&](Env& env) {
-            return std::chrono::duration_cast<std::chrono::seconds>(
-                       env.app()
-                           .getLedgerMaster()
-                           .getValidatedLedger()
-                           ->info()
-                           .parentCloseTime.time_since_epoch())
-                .count();
-        };
-
-        // Native Reward Claim
-        {
-            Env env{*this, features};
-            auto const alice = Account("alice");
-            auto const gw = Account("gw");
-
-            auto const issuer = Account::master;
-            env.fund(XRP(10001), alice, gw);
-            env.close();
-
-            env(hook(issuer, {{hso(jtx::genesis::AcceptHook)}}, 0),
-                fee(XRP(1)));
-            env.close();
-
-            auto const currentTime = getCurrentTime(env);
-            auto const currentLedger = env.current()->seq();
-
-            env(reward::claim(alice), reward::issuer(issuer), fee(XRP(1)));
-            env.close();
-
-            env(fset(alice, 0));
-            env.close();
-
-            BEAST_EXPECT(
-                expectRewards(
-                    env,
-                    alice,
-                    currentLedger,
-                    currentLedger + 1,
-                    10000,  // 10000 XAH * time 1
-                    currentTime) == true);
-        }
-
-        // IOU Reward Claim
-        for (bool const fromHighAccount : {true, false})
-        {
-            Env env{*this, features};
-            auto const alice = Account("alice");
-            auto const bob = Account("bob");
-            auto const issuer = Account("issuer");
-
-            auto const user = fromHighAccount ? alice : bob;
-            auto const gw = fromHighAccount ? bob : alice;
-
-            if (fromHighAccount)
-                BEAST_EXPECT(user.id() < gw.id());
-            else
-                BEAST_EXPECT(user.id() > gw.id());
-
-            env.fund(XRP(10000), user, gw, issuer);
-            env(fset(gw, asfDefaultRipple));
-
-            auto hookObj = hso(jtx::genesis::AcceptHook);
-            hookObj[jss::HookOn] = to_string(~UINT256_BIT[ttCLAIM_REWARD]);
-            env(hook(gw, {{hookObj}}, 0), fee(XRP(1)));
-            env.close();
-
-            env(trust(user, gw["USD"](1000000)), fee(XRP(1)));
-            env.close();
-            env(pay(gw, user, gw["USD"](10000)));
-            env.close();
-
-            auto currentTime = getCurrentTime(env);
-            auto currentLedger = env.current()->seq();
-
-            env(reward::claim(user),
-                reward::issuer(gw),
-                reward::claimCurrency(gw["USD"]),
-                fee(XRP(1)));
-            env.close();
-
-            env(pay(user, gw, gw["USD"](10000)));
-            env.close();
-
-            BEAST_EXPECT(
-                expectRewardsIOU(
-                    env,
-                    user,
-                    gw["USD"],
-                    currentLedger,
-                    currentLedger + 1,
-                    user["USD"](10000),  // 10000 USD * time 1
-                    currentTime) == true);
-
-            env(pay(gw, user, gw["USD"](1)));
-            env.close();
-
-            // check Balance == 0
-            BEAST_EXPECT(
-                expectRewardsIOU(
-                    env,
-                    user,
-                    gw["USD"],
-                    currentLedger,
-                    currentLedger + 2,
-                    user["USD"](10000),  // 10000 USD * time 1 + 0 USD * time 1
-                    currentTime) == true);
-        }
-
-        // Check Balance minus -> plus, plus -> minus
-        for (bool const fromHighAccount : {true, false})
-        {
-            Env env{*this, features};
-            auto const alice = Account("alice");
-            auto const bob = Account("bob");
-            auto const issuer = Account("issuer");
-
-            auto const user = fromHighAccount ? alice : bob;
-            auto const gw = fromHighAccount ? bob : alice;
-
-            if (fromHighAccount)
-                BEAST_EXPECT(user.id() < gw.id());
-            else
-                BEAST_EXPECT(user.id() > gw.id());
-
-            env.fund(XRP(10000), user, gw, issuer);
-            env(fset(gw, asfDefaultRipple));
-            env.close();
-
-            auto hookObj = hso(jtx::genesis::AcceptHook);
-            hookObj[jss::HookOn] = to_string(~UINT256_BIT[ttCLAIM_REWARD]);
-            env(hook(gw, {{hookObj}}, 0), fee(XRP(1)));
-            env.close();
-
-            env(trust(user, gw["USD"](1000000)));
-            env.close();
-            env(trust(gw, user["USD"](1000000)));
-            env(pay(gw, user, gw["USD"](10000)));
-            env.close();
-
-            auto currentTime = getCurrentTime(env);
-            auto currentLedger = env.current()->seq();
-
-            env(reward::claim(user),
-                reward::issuer(gw),
-                reward::claimCurrency(gw["USD"]),
-                fee(XRP(1)));
-            env.close();
-
-            env(pay(user, gw, gw["USD"](20000)));
-            env.close();
-
-            env(pay(user, gw, gw["USD"](1)));
-            env.close();
-
-            BEAST_EXPECT(
-                expectRewardsIOU(
-                    env,
-                    user,
-                    gw["USD"],
-                    currentLedger,
-                    currentLedger + 2,
-                    user["USD"](10000),  // 10000 USD * time 1 + 0 USD * time 1
-                    currentTime) == true);
-        }
-
-        // test with escrow (locked balance)
-        for (bool const fromHighAccount : {true, false})
-        {
-            for (bool const hasEscrow : {true, false})
-            {
-                Env env{*this, features};
-                auto const alice = Account("alice");
-                auto const bob = Account("bob");
-                auto const issuer = Account("issuer");
-
-                auto const user = fromHighAccount ? alice : bob;
-                auto const gw = fromHighAccount ? bob : alice;
-
-                if (fromHighAccount)
-                    BEAST_EXPECT(user.id() < gw.id());
-                else
-                    BEAST_EXPECT(user.id() > gw.id());
-
-                env.fund(XRP(10000), user, gw, issuer);
-                env(fset(gw, asfDefaultRipple));
-
-                auto hookObj = hso(jtx::genesis::AcceptHook);
-                hookObj[jss::HookOn] = to_string(~UINT256_BIT[ttCLAIM_REWARD]);
-                env(hook(gw, {{hookObj}}, 0), fee(XRP(1)));
-                env.close();
-
-                env(trust(user, gw["USD"](1000000)), fee(XRP(1)));
-                env.close();
-                env(pay(gw, user, gw["USD"](10000)));
-                env.close();
-
-                if (hasEscrow)
-                {
-                    env(escrow(user, user, gw["USD"](2000)),
-                        finish_time(env.now() + 1s),
-                        fee(XRP(1)));
-                    env.close();
-                }
-
-                auto currentTime = getCurrentTime(env);
-                auto currentLedger = env.current()->seq();
-
-                env(reward::claim(user),
-                    reward::issuer(gw),
-                    reward::claimCurrency(gw["USD"]),
-                    fee(XRP(1)));
-                env.close();
-                env(pay(user, gw, gw["USD"](5000)));
-                env.close();
-
-                BEAST_EXPECT(
-                    expectRewardsIOU(
-                        env,
-                        user,
-                        gw["USD"],
-                        currentLedger,
-                        currentLedger + 1,
-                        user["USD"](10000),  // 10000 USD * time 1
-                        currentTime) == true);
-
-                env(pay(gw, user, gw["USD"](1)));
-                env.close();
-
-                // check Balance == 0
-                BEAST_EXPECT(
-                    expectRewardsIOU(
-                        env,
-                        user,
-                        gw["USD"],
-                        currentLedger,
-                        currentLedger + 2,
-                        user["USD"](
-                            15000),  // 10000 USD * time 1 + 5000 USD * time 1
-                        currentTime) == true);
-            }
-        }
-
-        // STAmount overflow in reward accumulation should not cause
-        // transaction failure (tefEXCEPTION). The overflow should be
-        // gracefully skipped via try-catch.
-        for (bool const fromHighAccount : {true, false})
-        {
-            Env env{*this, features};
-            auto const alice = Account("alice");
-            auto const bob = Account("bob");
-            auto const issuer = Account("issuer");
-
-            auto const user = fromHighAccount ? alice : bob;
-            auto const gw = fromHighAccount ? bob : alice;
-
-            env.fund(XRP(10000), user, gw, issuer);
-            env(fset(gw, asfDefaultRipple));
-            env.close();
-
-            auto hookObj = hso(jtx::genesis::AcceptHook);
-            hookObj[jss::HookOn] = to_string(~UINT256_BIT[ttCLAIM_REWARD]);
-            env(hook(gw, {{hookObj}}, 0), fee(XRP(1)));
-            env.close();
-
-            // Use a near-max IOU balance at exponent 80. When
-            // multiply(balance, STAmount(lgrElapsed), issue) is called
-            // with lgrElapsed >= 2, the result exponent exceeds
-            // cMaxOffset(80), causing IOUAmount::normalize to throw
-            // std::overflow_error("value overflow").
-            auto const bigUSD = STAmount{
-                gw["USD"].issue(), std::uint64_t(5000000000000000ull), 80};
-            // Payment amount must be large enough to register a
-            // balance change given STAmount's 16-digit precision.
-            auto const payBackUSD = STAmount{
-                gw["USD"].issue(), std::uint64_t(1000000000000000ull), 80};
-
-            env(trust(user, bigUSD));
-            env.close();
-            env(pay(gw, user, bigUSD));
-            env.close();
-
-            // Claim IOU reward to initialize reward tracking
-            env(reward::claim(user),
-                reward::issuer(gw),
-                reward::claimCurrency(gw["USD"]),
-                fee(XRP(1)));
-            env.close();
-
-            // Advance ledger so lgrElapsed >= 2. With lgrElapsed=1
-            // the multiply result is exactly at cMaxOffset boundary
-            // (no overflow). With lgrElapsed >= 2, the result exponent
-            // exceeds cMaxOffset and triggers the overflow.
-            env.close();
-
-            // This payment modifies the trustline balance, triggering
-            // reward accumulation in Transactor. Without the try-catch
-            // fix, multiply() throws std::overflow_error("value overflow")
-            // and the transaction fails with tefEXCEPTION.
-            env(pay(user, gw, payBackUSD), ter(tesSUCCESS));
-            env.close();
-        }
-    }
-
     void
     testWithFeats(FeatureBitset features)
     {
@@ -1130,7 +377,6 @@ public:
         testInvalidPreclaim(features);
         testValidNoHook(features);
         testUsingTickets(features);
-        testBalanceChanges(features);
     }
 
 public:

src/test/app/DNS_test.cpp

@@ -61,7 +61,7 @@ public:
             pUrl_.domain,
             pUrl_.path,
             port_,
-            env_.app().getIOContext(),
+            env_.app().getIOService(),
             env_.journal,
             env_.app().config(),
             lastEndpoint,
@@ -78,11 +78,10 @@ public:
     isMultipleEndpoints()
     {
         using boost::asio::ip::tcp;
-        tcp::resolver resolver(env_.app().getIOContext());
+        tcp::resolver resolver(env_.app().getIOService());
         std::string port = pUrl_.port ? std::to_string(*pUrl_.port) : "443";
-        auto results = resolver.resolve(pUrl_.domain, port);
-        auto it = results.begin();
-        auto end = results.end();
+        tcp::resolver::iterator it = resolver.resolve(pUrl_.domain, port);
+        tcp::resolver::iterator end;
         int n = 0;
         for (; it != end; ++it)
             ++n;

src/test/app/DepositAuth_test.cpp

@@ -301,14 +301,8 @@ struct DepositAuth_test : public beast::unit_test::suite
             Env env(*this, features);
 
             env.fund(XRP(10000), gw1, alice, bob);
-            env(trust(
-                gw1,
-                alice["USD"](10),
-                noRipplePrev ? std::uint32_t(tfSetNoRipple) : 0));
-            env(trust(
-                gw1,
-                bob["USD"](10),
-                noRippleNext ? std::uint32_t(tfSetNoRipple) : 0));
+            env(trust(gw1, alice["USD"](10), noRipplePrev ? tfSetNoRipple : 0));
+            env(trust(gw1, bob["USD"](10), noRippleNext ? tfSetNoRipple : 0));
             env.trust(USD1(10), alice, bob);
 
             env(pay(gw1, alice, USD1(10)));
@@ -330,14 +324,8 @@ struct DepositAuth_test : public beast::unit_test::suite
             Env env(*this, features);
 
             env.fund(XRP(10000), gw1, gw2, alice);
-            env(trust(
-                alice,
-                USD1(10),
-                noRipplePrev ? std::uint32_t(tfSetNoRipple) : 0));
-            env(trust(
-                alice,
-                USD2(10),
-                noRippleNext ? std::uint32_t(tfSetNoRipple) : 0));
+            env(trust(alice, USD1(10), noRipplePrev ? tfSetNoRipple : 0));
+            env(trust(alice, USD2(10), noRippleNext ? tfSetNoRipple : 0));
             env(pay(gw2, alice, USD2(10)));
 
             if (withDepositAuth)

src/test/app/Escrow_test.cpp

@@ -18,7 +18,6 @@
 //==============================================================================
 
 #include <test/jtx.h>
-#include <test/jtx/AMM.h>
 #include <xrpld/app/tx/applySteps.h>
 #include <xrpld/ledger/Dir.h>
 #include <xrpl/protocol/Feature.h>
@@ -4317,93 +4316,6 @@ struct Escrow_test : public beast::unit_test::suite
         env.close();
     }
 
-    void
-    testIOUAMM(FeatureBitset features)
-    {
-        testcase("IOU AMM");
-        using namespace test::jtx;
-        using namespace std::chrono;
-
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account gw{"gw"};
-
-        auto const USD = gw["USD"];
-
-        // AMMCreate fails - insufficient balance
-        Env env(*this, features | featureAMM | featureAMMClawback);
-        env.fund(XRP(10000), alice, bob, gw);
-        env.close();
-
-        env.trust(USD(100000), alice);
-        env.close();
-        env(pay(gw, alice, USD(1000)));
-        env.close();
-
-        env(escrow(alice, bob, USD(1000)), finish_time(env.now() + 1s));
-        env.close();
-
-        // AMMCreate fails - insufficient balance
-        AMM ammFail(env, alice, XRP(1000), USD(1000), ter(tecUNFUNDED_AMM));
-
-        env(pay(gw, alice, USD(1000)));
-        env.close();
-
-        AMM ammAlice(env, alice, XRP(1000), USD(1000));
-        BEAST_EXPECT(ammAlice.ammExists());
-
-        // Single Asset Deposit fails - insufficient balance
-        ammAlice.deposit(
-            alice,
-            USD(1000),
-            std::nullopt,
-            std::nullopt,
-            std::nullopt,
-            ter(tecUNFUNDED_AMM));
-
-        // Double Asset Deposit fails - insufficient balance
-        ammAlice.deposit(
-            alice,
-            USD(1000),
-            XRP(1000),
-            std::nullopt,
-            std::nullopt,
-            ter(tecUNFUNDED_AMM));
-
-        auto const lptoken = ammAlice.getLPTokensBalance(alice);
-        // lock all LP tokens
-        env(escrow(alice, bob, STAmount{lptoken, ammAlice.lptIssue()}),
-            finish_time(env.now() + 1s));
-        env.close();
-
-        // Withdraw
-        ammAlice.withdraw(
-            alice, USD(1000), std::nullopt, std::nullopt, ter(tecAMM_BALANCE));
-        ammAlice.withdrawAll(alice, USD(1000), ter(tecAMM_BALANCE));
-
-        env(ammAlice.bid(BidArg{
-                .account = alice,
-                .bidMax = 100,
-                .assets = {{USD, XRP}},
-            }),
-            ter(tecAMM_INVALID_TOKENS));
-
-        ammAlice.vote(
-            alice,
-            1'000,
-            std::nullopt,
-            std::nullopt,
-            {{USD, XRP}},
-            ter(tecAMM_INVALID_TOKENS));
-
-        // Cannot escrow clawbackable tokens, so we cannot ammClawback escrowed
-        // tokens
-        // env(amm::ammClawback(gw, alice, USD, XRP, USD(100)),
-        //     ter(tecAMM_BALANCE));
-        // env(amm::ammClawback(gw, alice, USD, XRP, std::nullopt),
-        //     ter(tecAMM_BALANCE));
-    }
-
     static uint256
     getEscrowIndex(AccountID const& account, std::uint32_t uSequence)
     {
@@ -4422,160 +4334,216 @@ struct Escrow_test : public beast::unit_test::suite
         auto const gw = Account{"gateway"};
         auto const USD = gw["USD"];
 
-        Env env{*this, features};
-        env.fund(XRP(10000), alice, bob, gw);
-        env.close();
-        env.trust(USD(1000000), alice);
-        env.trust(USD(1000000), bob);
-        env.close();
-        env(pay(gw, alice, USD(10000)));
-        env(pay(gw, bob, USD(10000)));
-        env.close();
-
-        // EscrowCancel - EscrowID
+        for (bool const withXahauV1 : {true, false})
         {
-            uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 1s),
-                cancel_time(env.now() + 2s),
-                fee(1500));
+            auto const amend = withXahauV1 ? features : features - fixXahauV1;
+            Env env{*this, amend};
+            env.fund(XRP(10000), alice, bob, gw);
+            env.close();
+            env.trust(USD(1000000), alice);
+            env.trust(USD(1000000), bob);
+            env.close();
+            env(pay(gw, alice, USD(10000)));
+            env(pay(gw, bob, USD(10000)));
             env.close();
 
-            // withXahauV1 - no OfferSequence
-            env(cancel(bob, alice),
-                escrow_id(escrowId),
-                fee(1500),
-                ter(tesSUCCESS));
-            env.close();
+            // EscrowCancel - EscrowID
+            {
+                uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
+                env(escrow(alice, bob, USD(1000)),
+                    finish_time(env.now() + 1s),
+                    cancel_time(env.now() + 2s),
+                    fee(1500));
+                env.close();
 
-            auto const escrowLE = env.le(keylet::unchecked(escrowId));
-            BEAST_EXPECT(!escrowLE);
-        }
+                if (withXahauV1)
+                {
+                    // withXahauV1 - no OfferSequence
+                    env(cancel(bob, alice),
+                        escrow_id(escrowId),
+                        fee(1500),
+                        ter(tesSUCCESS));
+                    env.close();
+                }
+                else
+                {
+                    // !withXahauV1 - OfferSequence == 0
+                    env(cancel(bob, alice, 0),
+                        escrow_id(escrowId),
+                        fee(1500),
+                        ter(tesSUCCESS));
+                    env.close();
+                }
 
-        // EscrowCancel - no EscrowID or OfferSequence
-        {
-            uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 1s),
-                cancel_time(env.now() + 2s),
-                fee(1500));
-            env.close();
+                auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                BEAST_EXPECT(!escrowLE);
+            }
 
-            env(cancel(bob, alice), fee(1500), ter(temMALFORMED));
-            env.close();
+            // EscrowCancel - no EscrowID or OfferSequence
+            {
+                uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
+                env(escrow(alice, bob, USD(1000)),
+                    finish_time(env.now() + 1s),
+                    cancel_time(env.now() + 2s),
+                    fee(1500));
+                env.close();
 
-            auto const escrowLE = env.le(keylet::unchecked(escrowId));
-            BEAST_EXPECT(escrowLE);
-        }
+                env(cancel(bob, alice), fee(1500), ter(temMALFORMED));
+                env.close();
 
-        // EscrowCancel - EscrowID & OfferSequence
-        {
-            uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
-            auto const seq = env.seq(alice);
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 1s),
-                cancel_time(env.now() + 2s),
-                fee(1500));
-            env.close();
+                auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                BEAST_EXPECT(escrowLE);
+            }
 
-            env(cancel(bob, alice, seq),
-                escrow_id(escrowId),
-                fee(1500),
-                ter(temMALFORMED));
-            env.close();
+            // EscrowCancel - EscrowID & OfferSequence
+            {
+                uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
+                auto const seq = env.seq(alice);
+                env(escrow(alice, bob, USD(1000)),
+                    finish_time(env.now() + 1s),
+                    cancel_time(env.now() + 2s),
+                    fee(1500));
+                env.close();
 
-            auto const escrowLE = env.le(keylet::unchecked(escrowId));
-            BEAST_EXPECT(escrowLE);
-        }
+                env(cancel(bob, alice, seq),
+                    escrow_id(escrowId),
+                    fee(1500),
+                    ter(temMALFORMED));
+                env.close();
 
-        // EscrowCancel - EscrowID & OfferSequence 0
-        {
-            uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 1s),
-                cancel_time(env.now() + 2s),
-                fee(1500));
-            env.close();
+                auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                BEAST_EXPECT(escrowLE);
+            }
 
-            // withXahauV1 - OfferSequence 0 == temMALFORMED
-            env(cancel(bob, alice, 0),
-                escrow_id(escrowId),
-                fee(1500),
-                ter(temMALFORMED));
-            env.close();
-            auto const escrowLE = env.le(keylet::unchecked(escrowId));
-            BEAST_EXPECT(escrowLE);
-        }
+            // EscrowCancel - EscrowID & OfferSequence 0
+            {
+                uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
+                env(escrow(alice, bob, USD(1000)),
+                    finish_time(env.now() + 1s),
+                    cancel_time(env.now() + 2s),
+                    fee(1500));
+                env.close();
 
-        // EscrowFinish - EscrowID
-        {
-            uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 1s),
-                fee(1500));
-            env.close(5s);
+                if (withXahauV1)
+                {
+                    // withXahauV1 - OfferSequence 0 == temMALFORMED
+                    env(cancel(bob, alice, 0),
+                        escrow_id(escrowId),
+                        fee(1500),
+                        ter(temMALFORMED));
+                    env.close();
+                    auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                    BEAST_EXPECT(escrowLE);
+                }
+                else
+                {
+                    // withXahauV1 - OfferSequence 0 == tesSUCCESS
+                    env(cancel(bob, alice, 0),
+                        escrow_id(escrowId),
+                        fee(1500),
+                        ter(tesSUCCESS));
+                    env.close();
+                    auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                    BEAST_EXPECT(!escrowLE);
+                }
+            }
 
-            // withXahauV1 - no OfferSequence
-            env(finish(bob, alice),
-                escrow_id(escrowId),
-                fee(1500),
-                ter(tesSUCCESS));
-            env.close();
+            // EscrowFinish - EscrowID
+            {
+                uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
+                env(escrow(alice, bob, USD(1000)),
+                    finish_time(env.now() + 1s),
+                    fee(1500));
+                env.close(5s);
 
-            auto const escrowLE = env.le(keylet::unchecked(escrowId));
-            BEAST_EXPECT(!escrowLE);
-        }
+                if (withXahauV1)
+                {
+                    // withXahauV1 - no OfferSequence
+                    env(finish(bob, alice),
+                        escrow_id(escrowId),
+                        fee(1500),
+                        ter(tesSUCCESS));
+                    env.close();
+                }
+                else
+                {
+                    // !withXahauV1 - OfferSequence == 0
+                    env(finish(bob, alice, 0),
+                        escrow_id(escrowId),
+                        fee(1500),
+                        ter(tesSUCCESS));
+                    env.close();
+                }
 
-        // EscrowFinish - no EscrowID or OfferSequence
-        {
-            uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 1s),
-                fee(1500));
-            env.close();
+                auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                BEAST_EXPECT(!escrowLE);
+            }
 
-            env(finish(bob, alice), fee(1500), ter(temMALFORMED));
-            env.close();
+            // EscrowFinish - no EscrowID or OfferSequence
+            {
+                uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
+                env(escrow(alice, bob, USD(1000)),
+                    finish_time(env.now() + 1s),
+                    fee(1500));
+                env.close();
 
-            auto const escrowLE = env.le(keylet::unchecked(escrowId));
-            BEAST_EXPECT(escrowLE);
-        }
+                env(finish(bob, alice), fee(1500), ter(temMALFORMED));
+                env.close();
 
-        // EscrowFinish- EscrowID & OfferSequence
-        {
-            uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
-            auto const seq = env.seq(alice);
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 1s),
-                fee(1500));
-            env.close(5s);
+                auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                BEAST_EXPECT(escrowLE);
+            }
 
-            env(finish(bob, alice, seq),
-                escrow_id(escrowId),
-                fee(1500),
-                ter(temMALFORMED));
-            env.close();
+            // EscrowFinish- EscrowID & OfferSequence
+            {
+                uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
+                auto const seq = env.seq(alice);
+                env(escrow(alice, bob, USD(1000)),
+                    finish_time(env.now() + 1s),
+                    fee(1500));
+                env.close(5s);
 
-            auto const escrowLE = env.le(keylet::unchecked(escrowId));
-            BEAST_EXPECT(escrowLE);
-        }
+                env(finish(bob, alice, seq),
+                    escrow_id(escrowId),
+                    fee(1500),
+                    ter(temMALFORMED));
+                env.close();
 
-        // EscrowFinish- EscrowID & OfferSequence 0
-        {
-            uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 1s),
-                fee(1500));
-            env.close(5s);
+                auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                BEAST_EXPECT(escrowLE);
+            }
 
-            // withXahauV1 - OfferSequence 0 == temMALFORMED
-            env(finish(bob, alice, 0),
-                escrow_id(escrowId),
-                fee(1500),
-                ter(temMALFORMED));
-            env.close();
-            auto const escrowLE = env.le(keylet::unchecked(escrowId));
-            BEAST_EXPECT(escrowLE);
+            // EscrowFinish- EscrowID & OfferSequence 0
+            {
+                uint256 const escrowId{getEscrowIndex(alice, env.seq(alice))};
+                env(escrow(alice, bob, USD(1000)),
+                    finish_time(env.now() + 1s),
+                    fee(1500));
+                env.close(5s);
+
+                if (withXahauV1)
+                {
+                    // withXahauV1 - OfferSequence 0 == temMALFORMED
+                    env(finish(bob, alice, 0),
+                        escrow_id(escrowId),
+                        fee(1500),
+                        ter(temMALFORMED));
+                    env.close();
+                    auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                    BEAST_EXPECT(escrowLE);
+                }
+                else
+                {
+                    // !withXahauV1 - OfferSequence 0 == tesSUCCESS
+                    env(finish(bob, alice, 0),
+                        escrow_id(escrowId),
+                        fee(1500),
+                        ter(tesSUCCESS));
+                    env.close();
+                    auto const escrowLE = env.le(keylet::unchecked(escrowId));
+                    BEAST_EXPECT(!escrowLE);
+                }
+            }
         }
     }
 
@@ -4722,359 +4690,6 @@ struct Escrow_test : public beast::unit_test::suite
         }
     }
 
-    void
-    testDestinationCancel(FeatureBitset features)
-    {
-        using namespace jtx;
-        using namespace std::chrono;
-
-        bool const enabled = features[featureEscrowDestinationCancel];
-        TER const destResult =
-            enabled ? TER{tesSUCCESS} : TER{tecNO_PERMISSION};
-
-        auto const alice = Account("alice");
-        auto const bob = Account("bob");
-        auto const carol = Account("carol");
-        auto const gw = Account{"gateway"};
-        auto const USD = gw["USD"];
-
-        auto const ownerDirEmpty = [](Env& env, Account const& acct) {
-            ripple::Dir dir(*env.current(), keylet::ownerDir(acct.id()));
-            return std::distance(dir.begin(), dir.end()) == 0;
-        };
-
-        {
-            testcase("Destination Cancel: before CancelAfter");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice, bob, carol);
-            env.close();
-
-            auto const seq = env.seq(alice);
-            env(escrow(alice, bob, XRP(1000)),
-                finish_time(env.now() + 100s),
-                cancel_time(env.now() + 200s));
-            env.close();
-
-            // Neither the owner nor a third party may cancel early.
-            env(cancel(alice, alice, seq), ter(tecNO_PERMISSION));
-            env(cancel(carol, alice, seq), ter(tecNO_PERMISSION));
-            env.close();
-
-            STAmount const preAlice = env.balance(alice);
-            env(cancel(bob, alice, seq), ter(destResult));
-            env.close();
-
-            if (enabled)
-            {
-                BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq)));
-                // Funds go back to the owner, not the destination.
-                env.require(balance(alice, preAlice + XRP(1000)));
-                BEAST_EXPECT(env.ownerCount(alice) == 0);
-                BEAST_EXPECT(ownerDirEmpty(env, alice));
-                BEAST_EXPECT(ownerDirEmpty(env, bob));
-            }
-            else
-            {
-                BEAST_EXPECT(env.le(keylet::escrow(alice.id(), seq)));
-                // Rejected outright: nothing moves.
-                env.require(balance(alice, preAlice));
-                BEAST_EXPECT(env.ownerCount(alice) == 1);
-                BEAST_EXPECT(!ownerDirEmpty(env, bob));
-            }
-        }
-
-        {
-            testcase("Destination Cancel: after FinishAfter");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice, bob);
-            env.close();
-
-            // Finishable, and with no CancelAfter, otherwise never cancellable.
-            auto const seq = env.seq(alice);
-            env(escrow(alice, bob, XRP(1000)), finish_time(env.now() + 1s));
-            env.close(5s);
-
-            env(cancel(alice, alice, seq), ter(tecNO_PERMISSION));
-            env(cancel(bob, alice, seq), ter(destResult));
-            env.close();
-
-            if (enabled)
-            {
-                BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq)));
-            }
-            else
-            {
-                BEAST_EXPECT(env.le(keylet::escrow(alice.id(), seq)));
-                env(finish(bob, alice, seq));
-                env.close();
-                BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq)));
-            }
-        }
-
-        {
-            testcase("Destination Cancel: conditional");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice, bob);
-            env.close();
-
-            // The destination does not need the fulfillment to decline.
-            auto const seq = env.seq(alice);
-            env(escrow(alice, bob, XRP(1000)),
-                condition(cb1),
-                cancel_time(env.now() + 200s));
-            env.close();
-
-            env(cancel(bob, alice, seq), ter(destResult));
-            env.close();
-
-            if (enabled)
-            {
-                BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq)));
-            }
-            else
-            {
-                BEAST_EXPECT(env.le(keylet::escrow(alice.id(), seq)));
-            }
-        }
-
-        {
-            testcase("Destination Cancel: self-escrow stays locked");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice);
-            env.close();
-
-            auto const seq = env.seq(alice);
-            env(escrow(alice, alice, XRP(1000)),
-                finish_time(env.now() + 100s),
-                cancel_time(env.now() + 200s));
-            env.close();
-
-            env(cancel(alice, alice, seq), ter(tecNO_PERMISSION));
-            env.close();
-
-            BEAST_EXPECT(env.le(keylet::escrow(alice.id(), seq)));
-        }
-
-        {
-            testcase("Destination Cancel: EscrowID");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice, bob);
-            env.close();
-
-            uint256 const escrowId{keylet::escrow(alice, env.seq(alice)).key};
-            env(escrow(alice, bob, XRP(1000)),
-                finish_time(env.now() + 100s),
-                cancel_time(env.now() + 200s));
-            env.close();
-
-            env(cancel(bob, alice), escrow_id(escrowId), ter(destResult));
-            env.close();
-
-            if (enabled)
-            {
-                BEAST_EXPECT(!env.le(keylet::unchecked(escrowId)));
-            }
-            else
-            {
-                BEAST_EXPECT(env.le(keylet::unchecked(escrowId)));
-            }
-        }
-
-        {
-            testcase("Destination Cancel: owner hook cannot block");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice, bob, carol);
-            env.close();
-
-            auto const seq = env.seq(alice);
-            env(escrow(alice, bob, XRP(1000)),
-                finish_time(env.now() + 1s),
-                cancel_time(env.now() + 2s));
-            env.close();
-            env.close();
-
-            // Past CancelAfter, so only the owner's hook stands in the way.
-            env(jtx::hook(alice, {{hso(jtx::genesis::RollbackHook)}}, 0),
-                fee(XRP(2)));
-            env.close();
-
-            // The owner stays a strong tsh when a third party cancels.
-            env(cancel(carol, alice, seq), fee(XRP(1)), ter(tecHOOK_REJECTED));
-            env.close();
-
-            if (enabled)
-            {
-                env(cancel(bob, alice, seq), fee(XRP(1)));
-                env.close();
-                BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq)));
-            }
-            else
-            {
-                env(cancel(bob, alice, seq),
-                    fee(XRP(1)),
-                    ter(tecHOOK_REJECTED));
-                env.close();
-                BEAST_EXPECT(env.le(keylet::escrow(alice.id(), seq)));
-            }
-        }
-
-        {
-            testcase("Destination Cancel: IOU");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice, bob, gw);
-            env.close();
-            env.trust(USD(10000), alice, bob);
-            env.close();
-            env(pay(gw, alice, USD(5000)));
-            env.close();
-
-            auto const seq = env.seq(alice);
-            env(escrow(alice, bob, USD(1000)),
-                finish_time(env.now() + 100s),
-                cancel_time(env.now() + 200s));
-            env.close();
-            BEAST_EXPECT(-lockedAmount(env, alice, gw, USD) == USD(1000));
-
-            env(cancel(bob, alice, seq), ter(destResult));
-            env.close();
-
-            if (enabled)
-            {
-                BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq)));
-                BEAST_EXPECT(-lockedAmount(env, alice, gw, USD) == USD(0));
-            }
-            else
-            {
-                BEAST_EXPECT(env.le(keylet::escrow(alice.id(), seq)));
-                BEAST_EXPECT(-lockedAmount(env, alice, gw, USD) == USD(1000));
-            }
-            env.require(balance(alice, USD(5000)));
-            env.require(balance(bob, USD(0)));
-        }
-
-        {
-            testcase("Destination Cancel: issuer-owned IOU");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice, gw);
-            env.close();
-            env.trust(USD(10000), alice);
-            env.close();
-
-            // An issuer escrowing its own IOU locks nothing, so the cancel
-            // only has to unwind the escrow itself.
-            auto const seq = env.seq(gw);
-            env(escrow(gw, alice, USD(1000)),
-                finish_time(env.now() + 100s),
-                cancel_time(env.now() + 200s));
-            env.close();
-            BEAST_EXPECT(env.ownerCount(gw) == 1);
-
-            env(cancel(gw, gw, seq), ter(tecNO_PERMISSION));
-            env(cancel(alice, gw, seq), ter(destResult));
-            env.close();
-
-            if (enabled)
-            {
-                BEAST_EXPECT(!env.le(keylet::escrow(gw.id(), seq)));
-                BEAST_EXPECT(env.ownerCount(gw) == 0);
-            }
-            else
-            {
-                BEAST_EXPECT(env.le(keylet::escrow(gw.id(), seq)));
-                BEAST_EXPECT(env.ownerCount(gw) == 1);
-            }
-            env.require(balance(alice, USD(0)));
-        }
-
-        {
-            testcase("Destination Cancel: owner hook chain not charged");
-            Env env{*this, features};
-            env.fund(XRP(5000), alice, bob, carol);
-            env.close();
-
-            auto const seq = env.seq(alice);
-            env(escrow(alice, bob, XRP(1000)),
-                finish_time(env.now() + 1s),
-                cancel_time(env.now() + 2s));
-            env.close();
-            env.close();
-
-            auto const feeFor = [&](Account const& acct) {
-                return calculateBaseFee(
-                    *env.current(), *env.jt(cancel(acct, alice, seq)).stx);
-            };
-
-            XRPAmount const bobBefore = feeFor(bob);
-            XRPAmount const carolBefore = feeFor(carol);
-
-            env(jtx::hook(alice, {{hso(jtx::genesis::RollbackHook)}}, 0),
-                fee(XRP(2)));
-            env.close();
-
-            // A third party still pays for the owner's (strong) hook chain.
-            BEAST_EXPECT(feeFor(carol) > carolBefore);
-
-            // The destination does too, but only without the amendment.
-            if (enabled)
-            {
-                BEAST_EXPECT(feeFor(bob) == bobBefore);
-            }
-            else
-            {
-                BEAST_EXPECT(feeFor(bob) > bobBefore);
-            }
-        }
-
-        {
-            // fix1571 is still a live (DefaultYes) amendment on Xahau, so the
-            // legacy CancelAfter check in EscrowCancel remains reachable.
-            testcase("Destination Cancel: without fix1571");
-            Env env{*this, features - fix1571};
-            env.fund(XRP(5000), alice, bob, carol);
-            env.close();
-
-            // No CancelAfter.
-            auto const seq1 = env.seq(alice);
-            env(escrow(alice, bob, XRP(1000)), finish_time(env.now() + 100s));
-
-            // CancelAfter in the future.
-            auto const seq2 = env.seq(alice);
-            env(escrow(alice, bob, XRP(1000)),
-                finish_time(env.now() + 100s),
-                cancel_time(env.now() + 200s));
-
-            // CancelAfter about to pass.
-            auto const seq3 = env.seq(alice);
-            env(escrow(alice, bob, XRP(1000)),
-                finish_time(env.now() + 1s),
-                cancel_time(env.now() + 2s));
-            env.close();
-
-            env(cancel(alice, alice, seq1), ter(tecNO_PERMISSION));
-            env(cancel(carol, alice, seq2), ter(tecNO_PERMISSION));
-            env(cancel(bob, alice, seq1), ter(destResult));
-            env(cancel(bob, alice, seq2), ter(destResult));
-            env.close();
-
-            if (enabled)
-            {
-                BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq1)));
-                BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq2)));
-            }
-            else
-            {
-                BEAST_EXPECT(env.le(keylet::escrow(alice.id(), seq1)));
-                BEAST_EXPECT(env.le(keylet::escrow(alice.id(), seq2)));
-            }
-
-            // Past CancelAfter anyone may cancel, with or without the
-            // amendment.
-            env(cancel(carol, alice, seq3));
-            env.close();
-            BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), seq3)));
-        }
-    }
-
     void
     testWithFeats(FeatureBitset features)
     {
@@ -5114,7 +4729,6 @@ struct Escrow_test : public beast::unit_test::suite
         testIOUTLINSF(features);
         testIOUPrecisionLoss(features);
         testIOUClawback(features);
-        testIOUAMM(features);
     }
 
 public:
@@ -5123,17 +4737,12 @@ public:
     {
         using namespace test::jtx;
         FeatureBitset const all{supported_amendments() | featureCredentials};
-        // The pre-existing suites assert that the destination cannot cancel
-        // early, so they run without featureEscrowDestinationCancel.
-        FeatureBitset const legacy{all - featureEscrowDestinationCancel};
-        testWithFeats(legacy - featurePaychanAndEscrowForTokens);
-        testWithFeats(legacy);
-        testIOUWithFeats(legacy - featureClawback);
-        testIOUWithFeats(legacy);
+        testWithFeats(all - featurePaychanAndEscrowForTokens);
+        testWithFeats(all);
+        testIOUWithFeats(all - featureClawback);
+        testIOUWithFeats(all);
         testEscrowID(all);
         testCredentials(all);
-        testDestinationCancel(legacy);
-        testDestinationCancel(all);
     }
 };
 

src/test/app/GenesisMint_test.cpp

@@ -336,7 +336,10 @@ struct GenesisMint_test : public beast::unit_test::suite
             env.close();
 
             // validate emitted txn
-            validateEmittedTxn(env, "tesSUCCESS", __LINE__);
+            auto const txResult = env.current()->rules().enabled(fixXahauV1)
+                ? "tesSUCCESS"
+                : "tecINTERNAL";
+            validateEmittedTxn(env, txResult, __LINE__);
         }
 
         // missing an amount
@@ -566,25 +569,39 @@ struct GenesisMint_test : public beast::unit_test::suite
             validateEmittedTxn(env, "tesSUCCESS", __LINE__);
         }
 
+        auto const amtResult = env.current()->rules().enabled(fixXahauV1)
+            ? 30000000ULL
+            : 10000000ULL;
         // try to include the same destination twice
-        env(invoke::invoke(
-                invoker,
-                env.master,
-                genesis::makeBlob({
-                    {greg.id(), XRP(10).value(), std::nullopt, std::nullopt},
-                    {greg.id(), XRP(10).value(), std::nullopt, std::nullopt},
-                })),
-            fee(XRP(1)),
-            ter(tesSUCCESS));
-        env.close();
-        env.close();
+        {
+            auto const txResult = env.current()->rules().enabled(fixXahauV1)
+                ? ter(tesSUCCESS)
+                : ter(tecHOOK_REJECTED);
+            env(invoke::invoke(
+                    invoker,
+                    env.master,
+                    genesis::makeBlob({
+                        {greg.id(),
+                         XRP(10).value(),
+                         std::nullopt,
+                         std::nullopt},
+                        {greg.id(),
+                         XRP(10).value(),
+                         std::nullopt,
+                         std::nullopt},
+                    })),
+                fee(XRP(1)),
+                txResult);
+            env.close();
+            env.close();
+        }
 
         // check
         {
             auto const le = env.le(keylet::account(greg.id()));
             BEAST_EXPECT(
                 !!le &&
-                le->getFieldAmount(sfBalance).xrp().drops() == 30000000ULL);
+                le->getFieldAmount(sfBalance).xrp().drops() == amtResult);
         }
 
         // trip the supply cap invariant
@@ -609,7 +626,7 @@ struct GenesisMint_test : public beast::unit_test::suite
             auto const le = env.le(keylet::account(greg.id()));
             BEAST_EXPECT(
                 !!le &&
-                le->getFieldAmount(sfBalance).xrp().drops() == 30000000ULL);
+                le->getFieldAmount(sfBalance).xrp().drops() == amtResult);
 
             auto const postCoins = env.current()->info().drops;
             auto const txnFee =
@@ -681,6 +698,7 @@ public:
         using namespace test::jtx;
         auto const sa = supported_amendments();
         testWithFeats(sa);
+        testWithFeats(sa - fixXahauV1);
         testWithFeats(sa - fixHookAPI20251128);
     }
 };

src/test/app/Import_test.cpp

@@ -19,8 +19,6 @@
 
 #include <test/app/Import_json.h>
 #include <test/jtx.h>
-#include <test/jtx/AMM.h>
-#include <test/jtx/CaptureLogs.h>
 #include <xrpld/app/ledger/LedgerMaster.h>
 #include <xrpld/app/misc/AmendmentTable.h>
 #include <xrpld/app/misc/HashRouter.h>
@@ -30,9 +28,7 @@
 #include <xrpl/json/json_reader.h>
 #include <xrpl/json/json_writer.h>
 #include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/Import.h>
-#include <xrpl/protocol/digest.h>
 #include <xrpl/protocol/jss.h>
 
 #define BEAST_REQUIRE(x)     \
@@ -197,35 +193,6 @@ class Import_test : public beast::unit_test::suite
             env(import::import(alice, tmpXpop), ter(temMALFORMED));
         }
 
-        auto const upperHash =
-            "E000CC0736630D66DAB573A2642E1BD0646DFB13A871B2CCFA6E4226F477D88C";
-        auto const makeList = [](std::string const& hash) {
-            Json::Value proof{Json::arrayValue};
-            for (int i = 0; i < 16; ++i)
-                proof.append(hash);
-            return proof;
-        };
-
-        // XPOP.transaction.proof list should be exactly 16 entries
-        {
-            Json::Value proof = makeList(upperHash);
-            proof.append(upperHash);
-            BEAST_EXPECT(syntaxCheckProof(proof, env.journal) == false);
-        }
-        // XPOP.transaction.proof list entry missing or wrong format
-        // (should be hex string with 64 characters)
-        {
-            Json::Value proof = makeList(upperHash);
-            proof[Json::Value::ArrayIndex{0}] = "wrong format";
-            BEAST_EXPECT(syntaxCheckProof(proof, env.journal) == false);
-        }
-        // XPOP.transaction.proof list entry has wrong format
-        {
-            Json::Value proof = makeList(upperHash);
-            proof[Json::Value::ArrayIndex{0}] = 1234;
-            BEAST_EXPECT(syntaxCheckProof(proof, env.journal) == false);
-        }
-
         // // XPOP.transaction.proof list should be exactly 16 entries
         //  {
         //     Json::Value tmpXpop =
@@ -366,58 +333,6 @@ class Import_test : public beast::unit_test::suite
                 tmpProof[jss::children]["3"];
             BEAST_EXPECT(syntaxCheckProof(tmpProof, env.journal) == false);
         }
-        // XPOP.transaction.proof tree node has wrong format
-        // invalid hash (must be hex)
-        {
-            Json::Value tmpProof = proof;
-            tmpProof[jss::children]["3"][jss::hash] =
-                "ZZ126BA0486ADAE575BBC5335E42E236275A452037CA9A876D1A8CDACA1AE5"
-                "42";
-            BEAST_EXPECT(syntaxCheckProof(tmpProof, env.journal) == false);
-        }
-        // XPOP.transaction.proof tree node has wrong format
-        // invalid key (must be hex)
-        {
-            Json::Value tmpProof = proof;
-            tmpProof[jss::children]["3"][jss::key] =
-                "ZZD6F6AB7D0A827DD1502B7B9571626A2B601DBE5BC786EF8ADD00E0CB7FCE"
-                "B3";
-            BEAST_EXPECT(syntaxCheckProof(tmpProof, env.journal) == false);
-        }
-        // XPOP.transaction.proof tree node has wrong format (root)
-        // invalid root hash (must be hex)
-        {
-            Json::Value tmpProof = proof;
-            tmpProof[jss::hash] =
-                "ZZ9C8D073DDB5AB07FD2CD4F14467A8F3BC8FFBA16A0032D12D823D8511C12"
-                "F4";
-            BEAST_EXPECT(syntaxCheckProof(tmpProof, env.journal) == false);
-        }
-        // XPOP.transaction.proof child node was not 0-F hex nibble
-        // lower case nibble
-        {
-            Json::Value tmpProof = proof;
-            tmpProof[jss::children]["a"] = tmpProof[jss::children]["3"];
-            BEAST_EXPECT(syntaxCheckProof(tmpProof, env.journal) == false);
-        }
-        // success: hash and key values may be upper or lower case hex. Only
-        // child branch keys are constrained to upper case 0-F.
-        {
-            Json::Value tmpProof = proof;
-            tmpProof[jss::hash] =
-                "409c8d073ddb5ab07fd2cd4f14467a8f3bc8ffba16a0032d12d823d8511c12"
-                "f4";
-            tmpProof[jss::key] =
-                "00000000000000000000000000000000000000000000000000000000000000"
-                "00";
-            tmpProof[jss::children]["3"][jss::hash] =
-                "aa126ba0486adae575bbc5335e42e236275a452037ca9a876d1a8cdaca1ae5"
-                "42";
-            tmpProof[jss::children]["3"][jss::key] =
-                "39d6f6ab7d0a827dd1502b7b9571626a2b601dbe5bc786ef8add00e0cb7fce"
-                "b3";
-            BEAST_EXPECT(syntaxCheckProof(tmpProof, env.journal) == true);
-        }
         // success
         {
             BEAST_EXPECT(syntaxCheckProof(proof, env.journal) == true);
@@ -1568,117 +1483,6 @@ class Import_test : public beast::unit_test::suite
         }
     }
 
-    // Returns the XPOP with its blob/meta pair optionally tampered with
-    // (tamperMeta bumps the metadata's TransactionIndex, so the pair no longer
-    // hashes to any leaf in the proof) and, if plant is set, that pair's leaf
-    // hash written over the declared hash of the proof's nibble 0 child. In
-    // the w_seed fixture that child is an inner node, whose declared hash the
-    // txroot computation ignores.
-    static Json::Value
-    spoofInnerNode(Json::Value xpop, bool tamperMeta, bool plant)
-    {
-        auto& txn = xpop[jss::transaction];
-        auto const rawTx = *strUnHex(txn[jss::blob].asString());
-        auto rawMeta = *strUnHex(txn[jss::meta].asString());
-
-        if (tamperMeta)
-        {
-            STObject meta(
-                SerialIter(rawMeta.data(), rawMeta.size()), sfMetadata);
-            meta.setFieldU32(
-                sfTransactionIndex, meta.getFieldU32(sfTransactionIndex) + 1);
-            Serializer ms;
-            meta.add(ms);
-            rawMeta = ms.peekData();
-            txn[jss::meta] = strHex(rawMeta);
-        }
-
-        if (plant)
-        {
-            // leaf hash exactly as Import::preflight computes it
-            STTx const stx(SerialIter(rawTx.data(), rawTx.size()));
-            Serializer s(rawTx.size() + rawMeta.size() + 40);
-            s.addVL(rawTx);
-            s.addVL(rawMeta);
-            s.addBitString(stx.getTransactionID());
-            txn[jss::proof][jss::children]["0"][jss::hash] =
-                strHex(sha512Half(HashPrefix::txNode, s.slice()));
-        }
-
-        return xpop;
-    }
-
-    void
-    testProofInnerNodeSpoof(FeatureBitset features)
-    {
-        testcase("import proof inner node spoof");
-
-        using namespace test::jtx;
-        using namespace std::literals;
-
-        // the spoof relies on nibble 0 being an inner node in this fixture
-        auto const fixture = import::loadXpop(ImportTCAccountSet::w_seed);
-        auto const& nibble0 =
-            fixture[jss::transaction][jss::proof][jss::children]["0"];
-        BEAST_EXPECT(nibble0[jss::children].size() != 0);
-
-        std::string const notContained =
-            "xpop proof did not contain the specified txn hash";
-
-        // import the (possibly spoofed) w_seed XPOP into a fresh account and
-        // return the captured log
-        auto const runImport =
-            [&](bool tamperMeta, bool plant, TER expected) -> std::string {
-            std::string logs;
-            {
-                test::jtx::Env env{
-                    *this,
-                    network::makeNetworkVLConfig(21337, keys),
-                    features,
-                    std::make_unique<CaptureLogs>(&logs),
-                    beast::severities::kWarning};
-
-                // burn 10'000 xrp
-                auto const master = Account("masterpassphrase");
-                env(noop(master), fee(10'000'000'000), ter(tesSUCCESS));
-                env.close();
-
-                auto const alice = Account("alice");
-                env.memoize(alice);
-
-                Json::Value tx = import::import(
-                    alice, spoofInnerNode(fixture, tamperMeta, plant));
-                tx[jss::Sequence] = 0;
-                tx[jss::Fee] = 0;
-                env(tx, alice, ter(expected));
-                env.close();
-
-                auto const [acct, acctSle] =
-                    accountKeyAndSle(*env.current(), alice);
-                BEAST_EXPECT((acctSle != nullptr) == isTesSuccess(expected));
-            }
-            return logs;
-        };
-
-        // control: overwriting the inner node's declared hash alone leaves the
-        // computed txroot unchanged, so the genuine pair still imports
-        BEAST_EXPECT(
-            runImport(false, true, tesSUCCESS).find(notContained) ==
-            std::string::npos);
-
-        // a tampered blob/meta pair is not in the proof
-        BEAST_EXPECT(
-            runImport(true, false, temMALFORMED).find(notContained) !=
-            std::string::npos);
-
-        // spoof: the tampered pair's hash planted on the inner node. The
-        // txroot still verifies (see control), so the containment check is
-        // the only thing that can reject it
-        BEAST_EXPECT(
-            runImport(true, true, temMALFORMED).find(notContained) !=
-            std::string::npos);
-    }
-
     void
     testGetVLInfo(FeatureBitset features)
     {
@@ -1858,9 +1662,11 @@ class Import_test : public beast::unit_test::suite
 
         // temMALFORMED - Import: xpop did not contain an 80% quorum for the txn
         // it purports to prove.
+        for (bool const withXahauV1 : {true, false})
         {
+            auto const amend = withXahauV1 ? features : features - fixXahauV1;
             test::jtx::Env env{
-                *this, network::makeNetworkVLConfig(21337, keys), features};
+                *this, network::makeNetworkVLConfig(21337, keys), amend};
 
             auto const alice = Account("alice");
             env.fund(XRP(1000), alice);
@@ -1872,10 +1678,16 @@ class Import_test : public beast::unit_test::suite
                 "";
             valData["n9MTTavZe6EPqqyQ27pJbNWpfHw8ZNspVgznrwx5HWm7cdTjKQie"] =
                 "";
-            valData["n94J5LCRu9bBWrJiwRWujvuVECVPWbXFcQ2VN38qLD378F5pDSDM"] =
-                "";
+            if (withXahauV1)
+            {
+                valData
+                    ["n94J5LCRu9bBWrJiwRWujvuVECVPWbXFcQ2VN38qLD378F5pDSDM"] =
+                        "";
+            }
             tmpXpop[jss::validation][jss::data] = valData;
-            env(import::import(alice, tmpXpop), ter(temMALFORMED));
+            auto const txResult =
+                withXahauV1 ? ter(temMALFORMED) : ter(temMALFORMED);
+            env(import::import(alice, tmpXpop), txResult);
         }
 
         test::jtx::Env env{*this, network::makeNetworkVLConfig(21337, keys)};
@@ -1895,12 +1707,6 @@ class Import_test : public beast::unit_test::suite
         env.fund(XRP(1000), alice, bob, carol, dave);
         env.close();
 
-        auto const importWithUnlBlob = [&](std::string const& json) {
-            Json::Value tmpXpop = import::loadXpop(ImportTCAccountSet::w_seed);
-            tmpXpop[jss::validation][jss::unl][jss::blob] = base64_encode(json);
-            env(import::import(alice, tmpXpop), ter(temMALFORMED));
-        };
-
         // temMALFORMED
         // Issuer cannot be the source account.
         {
@@ -1914,7 +1720,7 @@ class Import_test : public beast::unit_test::suite
         {
             Json::Value tx = import::import(
                 alice, import::loadXpop(ImportTCAccountSet::w_seed));
-            STAmount const fee = XRP(0);
+            STAmount const& fee = XRP(0);
             tx[jss::Fee] = fee.getJson(JsonOptions::none);
             env(tx, ter(telINSUF_FEE_P));
         }
@@ -1933,7 +1739,7 @@ class Import_test : public beast::unit_test::suite
         {
             Json::Value tx = import::import(
                 alice, import::loadXpop(ImportTCAccountSet::w_seed));
-            STAmount const amount = XRP(-1);
+            STAmount const& amount = XRP(-1);
             tx[jss::Amount] = amount.getJson(JsonOptions::none);
             env(tx, ter(temMALFORMED));
         }
@@ -2277,12 +2083,6 @@ class Import_test : public beast::unit_test::suite
                 "WFo3VFFFPSJ9XX0=";
             env(import::import(alice, tmpXpop), ter(temMALFORMED));
         }
-        // temMALFORMED - Import: unl blob json (after base64 decoding) wrong
-        // required field (sequence) and/or types: negative int
-        {
-            importWithUnlBlob(
-                R"({"sequence":-1,"expiration":741398400,"validators":[]})");
-        }
         // temMALFORMED - Import: unl blob json (after base64 decoding)
         // lacked required field (expiration) and/or types
         {
@@ -2334,12 +2134,6 @@ class Import_test : public beast::unit_test::suite
                 "WFo3VFFFPSJ9XX0=";
             env(import::import(alice, tmpXpop), ter(temMALFORMED));
         }
-        // temMALFORMED - Import: unl blob json (after base64 decoding) wrong
-        // required field (expiration) and/or types: negative int
-        {
-            importWithUnlBlob(
-                R"({"sequence":2,"expiration":-1,"validators":[]})");
-        }
         // temMALFORMED - Import: unl blob json (after base64 decoding)
         // lacked required field (effective) and/or types
         {
@@ -2366,13 +2160,6 @@ class Import_test : public beast::unit_test::suite
                 "WGJuS1dqVmhxTmFHbTU3N0s2SjY5N1haN1RRRT0ifV19";
             env(import::import(alice, tmpXpop), ter(temMALFORMED));
         }
-        // temMALFORMED - Import: unl blob json (after base64 decoding) wrong
-        // required field (effective) and/or types: negative int
-        {
-            importWithUnlBlob(
-                R"({"sequence":2,"effective":-1,"expiration":741398400,)"
-                R"("validators":[]})");
-        }
         // temMALFORMED - Import: unl blob json (after base64 decoding)
         // lacked required field (validators) and/or types
         {
@@ -2421,10 +2208,7 @@ class Import_test : public beast::unit_test::suite
             env(import::import(alice, tmpXpop), ter(temMALFORMED));
         }
 
-        // temMALFORMED - unl blob expired. The window is now checked in
-        // preclaim (see testVLWindowClock). This blob's validator list
-        // does not match the xpop's validations, so preflight rejects it
-        // first.
+        // temMALFORMED - Import: unl blob expired
         {
             Json::Value tmpXpop = import::loadXpop(ImportTCAccountSet::w_seed);
             tmpXpop[jss::validation][jss::unl][jss::blob] =
@@ -2454,10 +2238,7 @@ class Import_test : public beast::unit_test::suite
             env(import::import(alice, tmpXpop), ter(temMALFORMED));
         }
 
-        // temMALFORMED - unl blob not yet valid. The window is now checked in
-        // preclaim (see testVLWindowClock). This blob's validator list
-        // does not match the xpop's validations, so preflight rejects it
-        // first.
+        // temMALFORMED - Import: unl blob not yet valid
         {
             Json::Value tmpXpop = import::loadXpop(ImportTCAccountSet::w_seed);
             tmpXpop[jss::validation][jss::unl][jss::blob] =
@@ -2854,78 +2635,6 @@ class Import_test : public beast::unit_test::suite
                 ter(temDISABLED));
         }
 
-        // tecNO_ISSUER, tecNO_PERMISSION
-        // issuer not found, issuer is an AMM account
-        {
-            auto const alice = Account("alice");
-            auto const bob = Account("bob");
-            auto const issuer = Account("issuer");
-            auto const USD = issuer["USD"];
-
-            for (bool const withFixImportIssuer : {true, false})
-            {
-                auto const amend =
-                    withFixImportIssuer ? features : features - fixImportIssuer;
-                test::jtx::Env env{
-                    *this, network::makeNetworkVLConfig(21337, keys), amend};
-                env.fund(XRP(1000), alice, issuer);
-                env.close();
-
-                // burn 10'000 xrp
-                auto const master = Account("masterpassphrase");
-                env(noop(master), fee(10'000'000'000), ter(tesSUCCESS));
-                env.close();
-
-                env(import::import(
-                        alice, import::loadXpop(ImportTCAccountSet::w_seed)),
-                    import::issuer(bob),
-                    fee(100'000'000),
-                    withFixImportIssuer ? ter(tecNO_ISSUER) : ter(tesSUCCESS));
-                env.close();
-            }
-            for (bool const withFixImportIssuer : {true, false})
-            {
-                auto const withAMM = features | featureAMM;
-                auto const amend =
-                    withFixImportIssuer ? withAMM : withAMM - fixImportIssuer;
-                test::jtx::Env env{
-                    *this, network::makeNetworkVLConfig(21337, keys), amend};
-                env.fund(XRP(1000), alice, issuer);
-                env.close();
-
-                // burn 10'000 xrp
-                auto const master = Account("masterpassphrase");
-                env(noop(master), fee(10'000'000'000), ter(tesSUCCESS));
-                env.close();
-
-                AMM amm(env, issuer, XRP(100), USD(100));
-                BEAST_EXPECT(amm.ammExists());
-
-                env(import::import(
-                        alice, import::loadXpop(ImportTCAccountSet::w_seed)),
-                    import::issuer(amm.ammAccount()),
-                    fee(100'000'000),
-                    withFixImportIssuer ? ter(tecNO_PERMISSION)
-                                        : ter(tesSUCCESS));
-                env.close();
-            }
-
-            //     env.enableFeature(fixImportIssuer);
-            //     env.close();
-
-            //     env(import::import(
-            //             carol, import::loadXpop(ImportTCAccountSet::w_seed)),
-            //         import::issuer(bob),
-            //         ter(tecNO_ISSUER));
-            //     env.close();
-            //     env(import::import(
-            //             dave, import::loadXpop(ImportTCAccountSet::w_seed)),
-            //         import::issuer(amm.ammAccount()),
-            //         // fee(100'000'000),
-            //         ter(tecNO_PERMISSION));
-            //     env.close();
-        }
-
         // tefINTERNAL
         // during preclaim could not parse xpop, bailing.
         {
@@ -5456,6 +5165,7 @@ class Import_test : public beast::unit_test::suite
                 *this, network::makeNetworkVLConfig(21337, keys)};
 
             auto const feeDrops = env.current()->fees().base;
+            bool const fixV2 = env.current()->rules().enabled(fixXahauV2);
 
             // confirm total coins header
             auto const initCoins = env.current()->info().drops;
@@ -5505,17 +5215,18 @@ class Import_test : public beast::unit_test::suite
             auto const preAlice = env.balance(alice);
             auto const preCoins = env.current()->info().drops;
 
+            auto const result = fixV2 ? ter(tesSUCCESS) : ter(tecHOOK_REJECTED);
             env(import::import(
                     alice, import::loadXpop(ImportTCAccountSet::w_seed)),
                 import::issuer(issuer),
                 fee(1'000'000),
-                ter(tesSUCCESS));
+                result);
             env.close();
 
             // fixXahauV2
             bool const zeroBurn =
                 env.current()->rules().enabled(featureZeroB2M);
-            auto const mintXAH = XRP(zeroBurn ? 0 : 1000);
+            auto const mintXAH = fixV2 ? XRP(zeroBurn ? 0 : 1000) : XRP(0);
             // confirm fee was burned mint / no mint
             auto const postAlice = env.balance(alice);
             BEAST_EXPECT(postAlice == preAlice - XRP(1) + mintXAH);
@@ -5525,14 +5236,17 @@ class Import_test : public beast::unit_test::suite
             BEAST_EXPECT(postCoins == preCoins - XRP(1) + mintXAH);
 
             // resubmit import without issuer
+            auto const result2 =
+                fixV2 ? ter(tefPAST_IMPORT_SEQ) : ter(tesSUCCESS);
             env(import::import(
                     alice, import::loadXpop(ImportTCAccountSet::w_seed)),
                 fee(feeDrops * 10),
-                ter(tefPAST_IMPORT_SEQ));
+                result2);
             env.close();
 
             // total burn
-            auto const totalBurn = XRP(0);
+            auto const totalBurn =
+                fixV2 ? XRP(0) : XRP(zeroBurn ? 0 : 1000) - (feeDrops * 10);
 
             // confirm fee was minted / not minted
             auto const postAlice2 = env.balance(alice);
@@ -6483,168 +6197,13 @@ class Import_test : public beast::unit_test::suite
         }
     }
 
-    void
-    testGetVLWindow(FeatureBitset features)
-    {
-        testcase("import utils - getVLWindow");
-
-        using namespace test::jtx;
-
-        beast::Journal const j{beast::Journal::getNullSink()};
-
-        auto const at = [](std::uint32_t s) {
-            return NetClock::time_point{NetClock::duration{s}};
-        };
-        auto const withBlob = [](std::string const& json) {
-            Json::Value xpop;
-            xpop[jss::validation][jss::unl][jss::blob] = base64_encode(json);
-            return xpop;
-        };
-
-        // effective absent: valid from the epoch
-        {
-            auto const window =
-                getVLWindow(import::loadXpop(ImportTCAccountSet::w_seed), j);
-            BEAST_REQUIRE(window);
-            BEAST_EXPECT(window->first == at(0));
-            BEAST_EXPECT(window->second == at(757349624));
-        }
-
-        // effective present
-        {
-            auto const window = getVLWindow(
-                withBlob(R"({"sequence":1,"effective":3600,)"
-                         R"("expiration":86400,"validators":[]})"),
-                j);
-            BEAST_REQUIRE(window);
-            BEAST_EXPECT(window->first == at(3600));
-            BEAST_EXPECT(window->second == at(86400));
-        }
-
-        // not json, not an object, or missing / ill-typed fields
-        for (std::string const bad :
-             {"badJson",
-              "[1,2,3]",
-              R"({"sequence":1})",
-              R"({"expiration":"86400"})",
-              R"({"expiration":-1})",
-              R"({"effective":"0","expiration":86400})",
-              R"({"effective":-1,"expiration":86400})"})
-            BEAST_EXPECT(!getVLWindow(withBlob(bad), j));
-    }
-
-    void
-    testVLWindowClock(FeatureBitset features)
-    {
-        testcase("import vl window clock");
-
-        using namespace test::jtx;
-
-        auto const at = [](std::uint32_t s) {
-            return NetClock::time_point{NetClock::duration{s}};
-        };
-
-        // expiration of the w_seed unl blob
-        std::uint32_t const expiry = 757349624;
-        auto const before = at(expiry - 1000);
-        auto const after = at(expiry + 1000);
-        auto const closeParentAt = [&](Env& env,
-                                       NetClock::time_point closeTime) {
-            using namespace std::chrono_literals;
-
-            auto const resolution = env.closed()->info().closeTimeResolution;
-            env.close(closeTime - resolution + 1s);
-        };
-
-        auto const alice = Account("alice");
-        auto const importTx = [&alice]() {
-            Json::Value tx = import::import(
-                alice, import::loadXpop(ImportTCAccountSet::w_seed));
-            tx[jss::Sequence] = 0;
-            tx[jss::Fee] = 0;
-            return tx;
-        };
-        // Keep this test focused on the VL clock, not max-supply accounting.
-        // w_seed creates an account and, without ZeroB2M, credits its 1000 XRP
-        // inner fee as valid legacy burn-to-mint.
-        auto const burnMintHeadroom = [&](Env& env) {
-            auto const initCoins = env.current()->info().drops;
-            auto headroom = Import::computeStartingBonus(*env.current());
-            if (!env.current()->rules().enabled(featureZeroB2M))
-                headroom += XRP(1000).value().xrp();
-            auto const master = Account("masterpassphrase");
-            env(noop(master),
-                fee(static_cast<std::uint64_t>(headroom.drops())),
-                ter(tesSUCCESS));
-            env.close();
-            BEAST_EXPECT(env.current()->info().drops == initCoins - headroom);
-        };
-
-        // parent ledger inside the window, node clock past it
-        {
-            Env env{*this, network::makeNetworkVLConfig(21337, keys), features};
-            burnMintHeadroom(env);
-            env.memoize(alice);
-            env.close(before);
-            BEAST_EXPECT(env.current()->parentCloseTime() < at(expiry));
-
-            env.timeKeeper().set(after);
-            env(importTx(), alice, ter(tesSUCCESS));
-            env.close();
-            BEAST_EXPECT(env.le(alice) != nullptr);
-        }
-
-        // parent ledger past the window, node clock inside it
-        {
-            Env env{*this, network::makeNetworkVLConfig(21337, keys), features};
-            burnMintHeadroom(env);
-            env.memoize(alice);
-            env.close(after);
-            BEAST_EXPECT(env.current()->parentCloseTime() >= at(expiry));
-
-            env.timeKeeper().set(before);
-            env(importTx(), alice, ter(temMALFORMED));
-            BEAST_EXPECT(env.le(alice) == nullptr);
-        }
-
-        // Env::close uses close-time resolution, so the requested expiration
-        // time lands on the closest representable parent close before
-        // expiration for this blob.
-        {
-            Env env{*this, network::makeNetworkVLConfig(21337, keys), features};
-            burnMintHeadroom(env);
-            env.memoize(alice);
-            closeParentAt(env, at(expiry));
-            BEAST_EXPECT(env.current()->parentCloseTime() < at(expiry));
-
-            env(importTx(), alice, ter(tesSUCCESS));
-            env.close();
-            BEAST_EXPECT(env.le(alice) != nullptr);
-        }
-
-        // accepted into the open ledger, which then closes after the window.
-        // Env::close() sets the node clock to the close time before the
-        // ledger is built, so this also covers the rebuild
-        {
-            Env env{*this, network::makeNetworkVLConfig(21337, keys), features};
-            burnMintHeadroom(env);
-            env.memoize(alice);
-            env.close(before);
-            env(importTx(), alice, ter(tesSUCCESS));
-            BEAST_EXPECT(env.le(alice) != nullptr);
-
-            env.close(after);
-            BEAST_EXPECT(env.closed()->info().parentCloseTime < at(expiry));
-            BEAST_EXPECT(env.le(alice) != nullptr);
-        }
-    }
-
 public:
     void
     run() override
     {
         using namespace test::jtx;
         FeatureBitset const all{supported_amendments()};
+        testWithFeats(all - fixXahauV2);
         testWithFeats(all - featureZeroB2M);
         testWithFeats(all);
     }
@@ -6660,7 +6219,6 @@ public:
         testSyntaxCheckProofArray(features);
         testSyntaxCheckProofObject(features);
         testSyntaxCheckXPOP(features);
-        testProofInnerNodeSpoof(features);
         testGetVLInfo(features);
         testEnabled(features);
         testInvalidPreflight(features);
@@ -6680,8 +6238,6 @@ public:
         testMinMax(features);
         testHalving(features - featureOwnerPaysFee);
         testBlackhole(features);
-        testGetVLWindow(features);
-        testVLWindowClock(features);
     }
 };
 

src/test/app/Invoke_test.cpp

@@ -18,7 +18,6 @@
 //==============================================================================
 
 #include <test/jtx.h>
-#include <test/jtx/AMM.h>
 #include <xrpl/protocol/jss.h>
 
 namespace ripple {
@@ -169,30 +168,6 @@ class Invoke_test : public beast::unit_test::suite
                 fee(feeDrops),
                 ter(tecNO_TARGET));
         }
-
-        // tecNO_PERMISSION
-        // issuer is an AMM account
-        {
-            test::jtx::Env env{
-                *this,
-                network::makeNetworkConfig(21337),
-                features | featureAMM};
-
-            auto const alice = Account("alice");
-            auto const issuer = Account("issuer");
-            auto const USD = issuer["USD"];
-            env.fund(XRP(1000), alice, issuer);
-            env.close();
-
-            AMM amm(env, issuer, XRP(100), USD(100));
-
-            BEAST_EXPECT(amm.ammExists());
-
-            env(invoke::invoke(alice),
-                invoke::dest(amm.ammAccount()),
-                ter(tecNO_PERMISSION));
-            env.close();
-        }
     }
 
     void

src/test/app/LPTokenTransfer_test.cpp

@@ -388,7 +388,7 @@ public:
     void
     run() override
     {
-        FeatureBitset const all{jtx::supported_amendments() | featureAMM};
+        FeatureBitset const all{jtx::supported_amendments()};
 
         testDirectStep(all);
         testBookStep(all);

src/test/app/LedgerMaster_test.cpp

@@ -20,8 +20,6 @@
 #include <test/jtx.h>
 #include <test/jtx/Env.h>
 #include <xrpld/app/ledger/LedgerMaster.h>
-#include <xrpld/app/ledger/detail/PublishGap.h>
-#include <xrpl/basics/RangeSet.h>
 #include <xrpl/protocol/jss.h>
 
 namespace ripple {
@@ -104,8 +102,8 @@ class LedgerMaster_test : public beast::unit_test::suite
                 startLegSeq, txnIndex);
             BEAST_EXPECT(
                 *result ==
-                uint256("DCAECE52F028B9D0F7CA43CBE15AB4EF7B84A8EF5D455238992E1E"
-                        "DF2BDA1637"));
+                uint256("0CC11AD1AD89661689F6B6148D82CB6A7101DA4D66EC843670262D"
+                        "0B618F5745"));
         }
         // success (second tx)
         {
@@ -114,229 +112,18 @@ class LedgerMaster_test : public beast::unit_test::suite
                 startLegSeq + 1, txnIndex);
             BEAST_EXPECT(
                 *result ==
-                uint256("722BD5EC9E4AE36E724B6223F5A5887927AADFD0B18A3053AAE57F"
-                        "434F8C9FE8"));
+                uint256("DCAECE52F028B9D0F7CA43CBE15AB4EF7B84A8EF5D455238992E1E"
+                        "DF2BDA1637"));
         }
     }
 
-    void
-    testCanSkipPinnedGap()
-    {
-        // detail::canSkipPinnedGap is the lifted decision used by
-        // findNewLedgersToPublish to decide whether pubSeq can leap
-        // across a gap in the publish-target set without violating
-        // contiguous publication of non-pinned ledgers. In production
-        // this guard rarely fires (pinned ranges are old historical
-        // catalogue data, pubSeq is at the live tip) — it matters in
-        // test/standalone catalogue-load scenarios where pinned seqs
-        // can sit near pubSeq. The invariant is small and crisp;
-        // unit-testing it directly is far cheaper than reconstructing
-        // a believable findNewLedgersToPublish state through Env.
-        testcase("detail::canSkipPinnedGap");
-
-        using detail::canSkipPinnedGap;
-
-        // No gap (pubSeq is already at intervalStart) — always OK.
-        {
-            RangeSet<std::uint32_t> empty;
-            BEAST_EXPECT(canSkipPinnedGap(10, 10, empty));
-            BEAST_EXPECT(canSkipPinnedGap(10, 5, empty));  // past
-        }
-
-        // One-element gap, exactly pinned: can skip.
-        {
-            RangeSet<std::uint32_t> pinned;
-            pinned.insert(range(10u, 10u));
-            BEAST_EXPECT(canSkipPinnedGap(10, 11, pinned));
-        }
-
-        // One-element gap, NOT pinned: must halt.
-        {
-            RangeSet<std::uint32_t> empty;
-            BEAST_EXPECT(!canSkipPinnedGap(10, 11, empty));
-        }
-
-        // Multi-element gap entirely covered by pinned: can skip.
-        {
-            RangeSet<std::uint32_t> pinned;
-            pinned.insert(range(11u, 15u));
-            BEAST_EXPECT(canSkipPinnedGap(11, 16, pinned));
-        }
-
-        // Multi-element gap, pinned covers most but leaves one
-        // non-pinned seq exposed: must halt. This is the bug the
-        // guard exists to prevent — silently publishing seq 16
-        // while seq 15 (non-pinned) is unfetched.
-        {
-            RangeSet<std::uint32_t> pinned;
-            pinned.insert(range(11u, 14u));  // missing 15
-            BEAST_EXPECT(!canSkipPinnedGap(11, 16, pinned));
-        }
-
-        // Pinned set extends beyond the gap — only the gap window
-        // matters for the decision.
-        {
-            RangeSet<std::uint32_t> pinned;
-            pinned.insert(range(0u, 1000u));
-            BEAST_EXPECT(canSkipPinnedGap(50, 100, pinned));
-        }
-
-        // Empty pinned, with a gap: must halt.
-        {
-            RangeSet<std::uint32_t> empty;
-            BEAST_EXPECT(!canSkipPinnedGap(50, 100, empty));
-        }
-
-        // Disjoint pinned that doesn't intersect the gap: must halt.
-        {
-            RangeSet<std::uint32_t> pinned;
-            pinned.insert(range(200u, 300u));
-            BEAST_EXPECT(!canSkipPinnedGap(50, 100, pinned));
-        }
-
-        // Pinned partially intersects gap from the left only.
-        {
-            RangeSet<std::uint32_t> pinned;
-            pinned.insert(range(50u, 75u));
-            BEAST_EXPECT(!canSkipPinnedGap(50, 100, pinned));
-        }
-
-        // Pinned partially intersects gap from the right only.
-        {
-            RangeSet<std::uint32_t> pinned;
-            pinned.insert(range(75u, 99u));
-            BEAST_EXPECT(!canSkipPinnedGap(50, 100, pinned));
-        }
-    }
-
-    void
-    testPinUnpinSymmetry()
-    {
-        testcase("pin/unpin symmetry");
-
-        using namespace test::jtx;
-        Env env{*this, makeNetworkConfig(11111)};
-
-        auto const alice = Account("alice");
-        env.fund(XRP(1000), alice);
-        env.close();
-
-        auto& lm = env.app().getLedgerMaster();
-
-        // The most recently closed ledger is the one we'll pin.
-        auto const ledger = lm.getClosedLedger();
-        BEAST_EXPECT(ledger);
-        if (!ledger)
-            return;
-        auto const seq = ledger->info().seq;
-        BEAST_EXPECT(seq > 0);
-
-        // Baseline — not pinned.
-        BEAST_EXPECT(!lm.isPinned(seq));
-
-        // Pin via storeLedger(ledger, pin=true). This is the same path
-        // catalogue_load uses just before saveValidatedLedger, which is why
-        // a save failure must roll back via unpinLedger() to keep the
-        // in-memory pinned-set consistent with state.db.
-        lm.storeLedger(ledger, /*pin=*/true);
-        BEAST_EXPECT(lm.isPinned(seq));
-        BEAST_EXPECT(boost::icl::contains(lm.getPinnedLedgersRangeSet(), seq));
-
-        // Unpin reverses the pin (the rollback contract used by
-        // catalogue_load's RAII guard on save failure).
-        lm.unpinLedger(seq);
-        BEAST_EXPECT(!lm.isPinned(seq));
-        BEAST_EXPECT(!boost::icl::contains(lm.getPinnedLedgersRangeSet(), seq));
-
-        // Unpinning a seq that isn't pinned is a no-op (idempotent).
-        lm.unpinLedger(seq);
-        BEAST_EXPECT(!lm.isPinned(seq));
-    }
-
-    void
-    testSetPinnedRangesImmediateMerge()
-    {
-        // Regression test: when setPinnedLedgersRangeSet runs and
-        // mCompleteLedgers is already non-empty (LOAD/standalone startup
-        // already called setFullLedger), the deferred merge in
-        // setFullLedger never fires because the one-shot guard relies on
-        // a flag, not on emptiness. Without the immediate-merge branch
-        // in setPinnedLedgersRangeSet, pinned ranges restored from
-        // state.db would never appear in mCompleteLedgers and historical
-        // pinned ledgers would not be queryable until the next
-        // validation. This test asserts the immediate-merge behavior.
-        testcase("setPinnedLedgersRangeSet immediate merge");
-
-        using namespace test::jtx;
-        Env env{*this, makeNetworkConfig(11111)};
-
-        auto const alice = Account("alice");
-        env.fund(XRP(1000), alice);
-        env.close();
-
-        auto& lm = env.app().getLedgerMaster();
-
-        // Why mCompleteLedgers is non-empty here:
-        //   env.close() above runs synchronous standalone consensus.
-        //   That hits LedgerMaster::switchLCL, which (in standalone)
-        //   calls setFullLedger directly on the calling thread, which
-        //   inserts the closed ledger's seq into mCompleteLedgers.
-        //   So by the time we get here, mCompleteLedgers has the
-        //   genesis + funded seqs in it.
-        //
-        // This is the precondition that triggers the immediate-merge
-        // branch in setPinnedLedgersRangeSet (the LOAD/standalone
-        // startup case). On a NORMAL/NETWORK production startup,
-        // mCompleteLedgers would still be empty when state.db is read
-        // and setPinnedLedgersRangeSet is called, and the merge would
-        // be deferred to the first validated ledger via setFullLedger.
-        // We're specifically testing the *other* branch here.
-        auto const completeBefore = lm.getCompleteLedgersRangeSet();
-        BEAST_EXPECT(!completeBefore.empty());
-
-        // Pinned ranges are far outside the existing range so we can
-        // unambiguously detect them being merged in.
-        std::uint32_t const pinLo = 100000;
-        std::uint32_t const pinHi = 100099;
-        RangeSet<std::uint32_t> pinned;
-        pinned.insert(range(pinLo, pinHi));
-
-        // Restore pinned ranges (mirrors what SHAMapStoreImp::start does
-        // after reading state.db's PinnedLedgers row).
-        lm.setPinnedLedgersRangeSet(pinned);
-
-        // Pinned set is restored.
-        BEAST_EXPECT(lm.isPinned(pinLo));
-        BEAST_EXPECT(lm.isPinned(pinHi));
-        BEAST_EXPECT(lm.isPinned((pinLo + pinHi) / 2));
-
-        // Critical invariant: pinned ranges are now in mCompleteLedgers
-        // immediately, not deferred to the first validated ledger.
-        // This is what makes haveLedger() return true for pinned seqs
-        // after a LOAD/standalone restart, without which the historical
-        // pinned data is on disk but the system reports "we don't have
-        // it".
-        BEAST_EXPECT(lm.haveLedger(pinLo));
-        BEAST_EXPECT(lm.haveLedger(pinHi));
-        BEAST_EXPECT(lm.haveLedger((pinLo + pinHi) / 2));
-
-        // The pre-existing complete range is still complete (merge,
-        // not replace).
-        for (auto const& interval : completeBefore)
-            for (auto s = interval.lower(); s <= interval.upper(); ++s)
-                BEAST_EXPECT(lm.haveLedger(s));
-    }
-
 public:
     void
     run() override
     {
         using namespace test::jtx;
         FeatureBitset const all{supported_amendments() - featureXahauGenesis};
-        testCanSkipPinnedGap();
         testWithFeats(all);
-        testPinUnpinSymmetry();
-        testSetPinnedRangesImmediateMerge();
     }
 
     void

src/test/app/LedgerReplay_test.cpp

@@ -1111,7 +1111,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
                 return false;
 
             beast::IP::Address addr =
-                boost::asio::ip::make_address("172.1.1.100");
+                boost::asio::ip::address::from_string("172.1.1.100");
             jtx::Env serverEnv(*this);
             serverEnv.app().config().LEDGER_REPLAY = server;
             auto http_resp = ripple::makeResponse(

src/test/app/LoadManager_test.cpp

@@ -1,203 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2025 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF  USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#include <test/jtx/Env.h>
-#include <test/jtx/envconfig.h>
-#include <xrpld/app/main/LoadManager.h>
-#include <xrpld/app/misc/LoadFeeTrack.h>
-#include <xrpl/beast/unit_test.h>
-#include <cstdint>
-
-namespace ripple {
-
-/**
- * Unit tests for LoadFeeTrack fee adjustment mechanics.
- *
- * These tests document the expected per-second behaviour of
- * raiseLocalFee() and lowerLocalFee() as called by LoadManager::run().
- *
- * Background: prior to the fix in this PR, the fee adjustment block in
- * LoadManager::run() was placed *outside* the while loop, meaning
- * raiseLocalFee()/lowerLocalFee() fired only once on shutdown rather
- * than every second during normal operation. localTxnLoadFee_ (and thus
- * load_factor_local in server_info) was therefore never adjusted by
- * local job queue load during normal operation.
- */
-class LoadManager_test : public beast::unit_test::suite
-{
-public:
-    // The normal/minimum fee factor (kLftNormalFee in LoadFeeTrack)
-    static constexpr std::uint32_t kNormalFee = 256;
-
-    void
-    testRaiseHysteresis()
-    {
-        testcase("raiseLocalFee requires two consecutive calls");
-
-        LoadFeeTrack track;
-
-        // First call: raiseCount_ goes from 0 to 1, returns false (hysteresis)
-        BEAST_EXPECT(!track.raiseLocalFee());
-        BEAST_EXPECT(track.getLocalFee() == kNormalFee);
-
-        // Second call: raiseCount_ reaches 2, fee is raised
-        BEAST_EXPECT(track.raiseLocalFee());
-        BEAST_EXPECT(track.getLocalFee() > kNormalFee);
-    }
-
-    void
-    testLowerDecaysToBaseline()
-    {
-        testcase("lowerLocalFee decays elevated fee back to baseline");
-
-        LoadFeeTrack track;
-
-        // Raise the fee above baseline (requires two calls due to hysteresis)
-        track.raiseLocalFee();
-        track.raiseLocalFee();
-        auto const elevated = track.getLocalFee();
-        BEAST_EXPECT(elevated > kNormalFee);
-
-        // lowerLocalFee() should decay it each call
-        // Each call reduces by 1/kLftFeeDecFraction (1/4), so a few
-        // iterations should bring it back to kNormalFee
-        bool changed = false;
-        for (int i = 0; i < 100; ++i)
-        {
-            changed |= track.lowerLocalFee();
-            if (track.getLocalFee() == kNormalFee)
-                break;
-        }
-
-        BEAST_EXPECT(changed);
-        BEAST_EXPECT(track.getLocalFee() == kNormalFee);
-    }
-
-    void
-    testLowerAtBaselineIsNoop()
-    {
-        testcase("lowerLocalFee at baseline returns false");
-
-        LoadFeeTrack track;
-
-        // Already at baseline — should return false (no change)
-        BEAST_EXPECT(!track.lowerLocalFee());
-        BEAST_EXPECT(track.getLocalFee() == kNormalFee);
-    }
-
-    void
-    testRaiseResetsOnLower()
-    {
-        testcase("lowerLocalFee resets raiseCount");
-
-        LoadFeeTrack track;
-
-        // One raise call (hysteresis: count=1, no change yet)
-        BEAST_EXPECT(!track.raiseLocalFee());
-
-        // Lower resets raiseCount_ to 0
-        track.lowerLocalFee();
-
-        // Next raise call starts from 0 again — still needs two calls
-        BEAST_EXPECT(!track.raiseLocalFee());
-        BEAST_EXPECT(track.getLocalFee() == kNormalFee);
-    }
-
-    void
-    testIsLoadedLocal()
-    {
-        testcase("isLoadedLocal reflects fee state correctly");
-
-        LoadFeeTrack track;
-
-        // At baseline, not loaded
-        BEAST_EXPECT(!track.isLoadedLocal());
-
-        // After one raise (hysteresis, fee unchanged) — raiseCount_ != 0
-        track.raiseLocalFee();
-        BEAST_EXPECT(track.isLoadedLocal());
-
-        // After lower, raiseCount_ reset and fee back at baseline
-        track.lowerLocalFee();
-        BEAST_EXPECT(!track.isLoadedLocal());
-    }
-
-    void
-    testLoadManagerLoop()
-    {
-        testcase("LoadManager loop raises and decays load_factor_local");
-
-        using namespace test::jtx;
-
-        Env env(*this, envconfig());
-
-        // Stop the real LoadManager thread so we can drive the fee track
-        // manually without races. On stock code the fee adjustment block
-        // is outside the while loop and never fires during normal operation,
-        // so getFeeTrack().getLocalFee() stays at kNormalFee (256) regardless.
-        env.app().getLoadManager().stop();
-
-        auto& feeTrack = env.app().getFeeTrack();
-
-        // Confirm baseline
-        BEAST_EXPECT(feeTrack.getLocalFee() == kNormalFee);
-        BEAST_EXPECT(!feeTrack.isLoadedLocal());
-
-        // raiseLocalFee() requires two consecutive calls (hysteresis guard).
-        // This is the exact sequence LoadManager::run() executes each tick
-        // when the job queue is overloaded.
-        BEAST_EXPECT(!feeTrack.raiseLocalFee());  // tick 1: count=1, no change
-        BEAST_EXPECT(feeTrack.raiseLocalFee());   // tick 2: count=2, fee raised
-        BEAST_EXPECT(feeTrack.getLocalFee() > kNormalFee);
-        BEAST_EXPECT(feeTrack.isLoadedLocal());
-
-        // Now simulate the LoadManager loop calling lowerLocalFee() each tick
-        // until the fee decays back to baseline. On stock code this block
-        // never runs during normal operation so the fee would stay elevated.
-        bool decayed = false;
-        for (int i = 0; i < 100; ++i)
-        {
-            feeTrack.lowerLocalFee();
-            if (feeTrack.getLocalFee() == kNormalFee)
-            {
-                decayed = true;
-                break;
-            }
-        }
-
-        BEAST_EXPECT(decayed);
-        BEAST_EXPECT(feeTrack.getLocalFee() == kNormalFee);
-        BEAST_EXPECT(!feeTrack.isLoadedLocal());
-    }
-
-    void
-    run() override
-    {
-        testRaiseHysteresis();
-        testLowerDecaysToBaseline();
-        testLowerAtBaselineIsNoop();
-        testRaiseResetsOnLower();
-        testIsLoadedLocal();
-        testLoadManagerLoop();
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(LoadManager, app, ripple);
-
-}  // namespace ripple