chore: Revert extra commits for 2.4.1 (#2133)

This reverts commit df3f1865ae.

.github/actions/build_clio/action.yml

@@ -4,12 +4,18 @@ inputs:
   target:
     description: Build target name
     default: all
+  substract_threads:
+    description: An option for the action get_number_of_threads. See get_number_of_threads 
+    required: true
+    default: '0'
 runs:
   using: composite
   steps:
     - name: Get number of threads
       uses: ./.github/actions/get_number_of_threads
       id: number_of_threads
+      with:
+        substract_threads: ${{ inputs.substract_threads }}
 
     - name: Build Clio
       shell: bash

.github/actions/generate/action.yml

@@ -12,6 +12,10 @@ inputs:
     description: Build type for third-party libraries and clio. Could be 'Release', 'Debug'
     required: true
     default: 'Release'
+  build_integration_tests:
+    description: Whether to build integration tests
+    required: true
+    default: 'true'
   code_coverage:
     description: Whether conan's coverage option should be on or not
     required: true
@@ -20,6 +24,10 @@ inputs:
     description: Whether Clio is to be statically linked
     required: true
     default: 'false'
+  sanitizer:
+    description: Sanitizer to use
+    required: true
+    default: 'false' # false, tsan, asan or ubsan
 runs:
   using: composite
   steps:
@@ -33,14 +41,20 @@ runs:
         BUILD_OPTION: "${{ inputs.conan_cache_hit == 'true' && 'missing' || '' }}"
         CODE_COVERAGE: "${{ inputs.code_coverage == 'true' && 'True' || 'False' }}"
         STATIC_OPTION: "${{ inputs.static == 'true' && 'True' || 'False' }}"
+        INTEGRATION_TESTS_OPTION: "${{ inputs.build_integration_tests == 'true' && 'True' || 'False' }}"
       run: |
         cd build
-        conan install .. -of . -b $BUILD_OPTION -s build_type=${{ inputs.build_type }} -o clio:static="${STATIC_OPTION}" -o clio:tests=True -o clio:integration_tests=True -o clio:lint=False -o clio:coverage="${CODE_COVERAGE}" --profile ${{ inputs.conan_profile }}
-
+        conan install .. -of . -b $BUILD_OPTION -s build_type=${{ inputs.build_type }} -o clio:static="${STATIC_OPTION}" -o clio:tests=True -o clio:integration_tests="${INTEGRATION_TESTS_OPTION}" -o clio:lint=False -o clio:coverage="${CODE_COVERAGE}" --profile ${{ inputs.conan_profile }}
+    
     - name: Run cmake
       shell: bash
       env:
         BUILD_TYPE: "${{ inputs.build_type }}"
+        SANITIZER_OPTION: |
+          ${{ inputs.sanitizer == 'tsan' && '-Dsan=thread' ||
+              inputs.sanitizer == 'ubsan' && '-Dsan=undefined' ||
+              inputs.sanitizer == 'asan' && '-Dsan=address' ||
+              '' }}
       run: |
         cd build
-        cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} ${{ inputs.extra_cmake_args }} .. -G Ninja
+        cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" ${SANITIZER_OPTION} .. -G Ninja

.github/actions/get_number_of_threads/action.yml

@@ -1,5 +1,10 @@
 name: Get number of threads
 description: Determines number of threads to use on macOS and Linux
+inputs:
+  substract_threads:
+    description: How many threads to substract from the calculated number 
+    required: true
+    default: '0'
 outputs:
   threads_number:
     description: Number of threads to use
@@ -19,8 +24,11 @@ runs:
       shell: bash
       run: echo "num=$(($(nproc) - 2))" >> $GITHUB_OUTPUT
 
-    - name: Export output variable
-      shell: bash
+    - name: Shift and export number of threads
       id: number_of_threads_export
+      shell: bash
       run: |
-        echo "num=${{ steps.mac_threads.outputs.num || steps.linux_threads.outputs.num }}" >> $GITHUB_OUTPUT
+        num_of_threads=${{ steps.mac_threads.outputs.num || steps.linux_threads.outputs.num }}
+        shift_by=${{ inputs.substract_threads }}
+        shifted=$((num_of_threads - shift_by))
+        echo "num=$(( shifted > 1 ? shifted : 1 ))" >> $GITHUB_OUTPUT

.github/actions/prepare_runner/action.yml

@@ -11,9 +11,35 @@ runs:
       if: ${{ runner.os == 'macOS' }}
       shell: bash
       run: |
-          brew install llvm@14 pkg-config ninja bison cmake ccache jq gh conan@1 ca-certificates
+          brew install llvm@14 pkg-config ninja bison ccache jq gh conan@1 ca-certificates
           echo "/opt/homebrew/opt/conan@1/bin" >> $GITHUB_PATH
 
+    - name: Install CMake 3.31.6 on mac
+      if: ${{ runner.os == 'macOS' }}
+      shell: bash
+      run: |
+          # Uninstall any existing cmake
+          brew uninstall cmake --ignore-dependencies || true
+          
+          # Download specific cmake formula
+          FORMULA_URL="https://raw.githubusercontent.com/Homebrew/homebrew-core/b4e46db74e74a8c1650b38b1da222284ce1ec5ce/Formula/c/cmake.rb"
+          FORMULA_EXPECTED_SHA256="c7ec95d86f0657638835441871e77541165e0a2581b53b3dd657cf13ad4228d4"
+          
+          mkdir -p /tmp/homebrew-formula
+          curl -s -L $FORMULA_URL -o /tmp/homebrew-formula/cmake.rb
+          
+          # Verify the downloaded formula
+          ACTUAL_SHA256=$(shasum -a 256 /tmp/homebrew-formula/cmake.rb | cut -d ' ' -f 1)
+          if [ "$ACTUAL_SHA256" != "$FORMULA_EXPECTED_SHA256" ]; then
+            echo "Error: Formula checksum mismatch"
+            echo "Expected: $FORMULA_EXPECTED_SHA256"
+            echo "Actual: $ACTUAL_SHA256"
+            exit 1
+          fi
+          
+          # Install cmake from the specific formula with force flag
+          brew install --force /tmp/homebrew-formula/cmake.rb
+
     - name: Fix git permissions on Linux
       if: ${{ runner.os == 'Linux' }}
       shell: bash

.github/scripts/execute-tests-under-sanitizer

@@ -0,0 +1,45 @@
+#!/bin/bash
+
+set -o pipefail
+
+# Note: This script is intended to be run from the root of the repository.
+#
+# This script runs each unit-test separately and generates reports from the currently active sanitizer.
+# Output is saved in ./.sanitizer-report in the root of the repository
+
+if [[ -z "$1" ]]; then
+    cat <<EOF
+
+                                    ERROR
+-----------------------------------------------------------------------------
+     Path to clio_tests should be passed as first argument to the script.
+-----------------------------------------------------------------------------
+
+EOF
+    exit 1
+fi
+
+TEST_BINARY=$1
+
+if [[ ! -f "$TEST_BINARY" ]]; then
+  echo "Test binary not found: $TEST_BINARY"
+  exit 1
+fi
+
+TESTS=$($TEST_BINARY --gtest_list_tests | awk '/^  / {print suite $1} !/^  / {suite=$1}')
+
+OUTPUT_DIR="./.sanitizer-report"
+mkdir -p "$OUTPUT_DIR"
+
+for TEST in $TESTS; do
+  OUTPUT_FILE="$OUTPUT_DIR/${TEST//\//_}"
+  export TSAN_OPTIONS="log_path=\"$OUTPUT_FILE\" die_after_fork=0"
+  export ASAN_OPTIONS="log_path=\"$OUTPUT_FILE\""
+  export UBSAN_OPTIONS="log_path=\"$OUTPUT_FILE\""
+  export MallocNanoZone='0' # for MacOSX
+  $TEST_BINARY --gtest_filter="$TEST" > /dev/null 2>&1
+
+  if [ $? -ne 0 ]; then
+    echo "'$TEST' failed a sanitizer check."
+  fi
+done

.github/workflows/build.yml

@@ -9,7 +9,7 @@ on:
 jobs:
   check_format:
     name: Check format
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     container:
       image: rippleci/clio_ci:latest
     steps:
@@ -26,7 +26,7 @@ jobs:
  
   check_docs:
     name: Check documentation
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     container:
       image: rippleci/clio_ci:latest
     steps:
@@ -47,133 +47,44 @@ jobs:
       matrix:
         include:
           - os: heavy
-            container:
-              image: rippleci/clio_ci:latest
-            build_type: Release
             conan_profile: gcc
+            build_type: Release
+            container: '{ "image": "rippleci/clio_ci:latest" }'
             code_coverage: false
             static: true
           - os: heavy
-            container:
-              image: rippleci/clio_ci:latest
-            build_type: Debug
             conan_profile: gcc
+            build_type: Debug
+            container: '{ "image": "rippleci/clio_ci:latest" }'
             code_coverage: true
             static: true
           - os: heavy
-            container:
-              image: rippleci/clio_ci:latest
-            build_type: Release
             conan_profile: clang
+            build_type: Release
+            container: '{ "image": "rippleci/clio_ci:latest" }'
             code_coverage: false
             static: true
           - os: heavy
-            container:
-              image: rippleci/clio_ci:latest
-            build_type: Debug
             conan_profile: clang
+            build_type: Debug
+            container: '{ "image": "rippleci/clio_ci:latest" }'
             code_coverage: false
             static: true
           - os: macos15
             build_type: Release
             code_coverage: false
             static: false
-    runs-on: [self-hosted, "${{ matrix.os }}"]
-    container: ${{ matrix.container }}
-
-    steps:
-      - name: Clean workdir
-        if: ${{ runner.os == 'macOS' }}
-        uses: kuznetsss/workspace-cleanup@1.0
-
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Prepare runner
-        uses: ./.github/actions/prepare_runner
-        with:
-          disable_ccache: false
-
-      - name: Setup conan
-        uses: ./.github/actions/setup_conan
-        id: conan
-        with:
-          conan_profile: ${{ matrix.conan_profile }}
-
-      - name: Restore cache
-        uses: ./.github/actions/restore_cache
-        id: restore_cache
-        with:
-          conan_dir: ${{ env.CONAN_USER_HOME }}/.conan
-          conan_profile: ${{ steps.conan.outputs.conan_profile }}
-          ccache_dir: ${{ env.CCACHE_DIR }}
-          build_type: ${{ matrix.build_type }}
-          code_coverage: ${{ matrix.code_coverage }}
-
-      - name: Run conan and cmake
-        uses: ./.github/actions/generate
-        with:
-          conan_profile: ${{ steps.conan.outputs.conan_profile }}
-          conan_cache_hit: ${{ steps.restore_cache.outputs.conan_cache_hit }}
-          build_type: ${{ matrix.build_type }}
-          code_coverage: ${{ matrix.code_coverage }}
-          static: ${{ matrix.static }}
-
-      - name: Build Clio
-        uses: ./.github/actions/build_clio
-
-      - name: Show ccache's statistics
-        shell: bash
-        id: ccache_stats
-        run: |
-          ccache -s > /tmp/ccache.stats
-          miss_rate=$(cat /tmp/ccache.stats | grep 'Misses' | head -n1 | sed 's/.*(\(.*\)%).*/\1/')
-          echo "miss_rate=${miss_rate}" >> $GITHUB_OUTPUT
-          cat /tmp/ccache.stats
-
-      - name: Strip tests
-        if: ${{ !matrix.code_coverage }}
-        run: strip build/clio_tests && strip build/clio_integration_tests
-
-      - name: Upload clio_server
-        uses: actions/upload-artifact@v4
-        with:
-          name: clio_server_${{ runner.os }}_${{ matrix.build_type }}_${{ steps.conan.outputs.conan_profile }}
-          path: build/clio_server
-
-      - name: Upload clio_tests
-        if: ${{ !matrix.code_coverage }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: clio_tests_${{ runner.os }}_${{ matrix.build_type }}_${{ steps.conan.outputs.conan_profile }}
-          path: build/clio_*tests
-
-      - name: Save cache
-        uses: ./.github/actions/save_cache
-        with:
-          conan_dir: ${{ env.CONAN_USER_HOME }}/.conan
-          conan_hash: ${{ steps.restore_cache.outputs.conan_hash }}
-          conan_cache_hit: ${{ steps.restore_cache.outputs.conan_cache_hit }}
-          ccache_dir: ${{ env.CCACHE_DIR }}
-          ccache_cache_hit: ${{ steps.restore_cache.outputs.ccache_cache_hit }}
-          ccache_cache_miss_rate: ${{ steps.ccache_stats.outputs.miss_rate }}
-          build_type: ${{ matrix.build_type }}
-          code_coverage: ${{ matrix.code_coverage }}
-          conan_profile: ${{ steps.conan.outputs.conan_profile }}
-
-      # TODO: This is not a part of build process but it is the easiest way to do it here.
-      # It will be refactored in https://github.com/XRPLF/clio/issues/1075
-      - name: Run code coverage
-        if: ${{ matrix.code_coverage }}
-        uses: ./.github/actions/code_coverage
-
-  upload_coverage_report:
-    name: Codecov
-    needs: build
-    uses: ./.github/workflows/upload_coverage_report.yml
-    secrets:
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+    uses: ./.github/workflows/build_impl.yml
+    with:
+      runs_on: ${{ matrix.os }}
+      container: ${{ matrix.container }}
+      conan_profile: ${{ matrix.conan_profile }}
+      build_type: ${{ matrix.build_type }}
+      code_coverage: ${{ matrix.code_coverage }}
+      static: ${{ matrix.static }}
+      unit_tests: true
+      integration_tests: true
+      clio_server: true
 
   test:
     name: Run Tests
@@ -183,24 +94,24 @@ jobs:
       matrix:
         include:
           - os: heavy
-            container:
-              image: rippleci/clio_ci:latest
             conan_profile: gcc
             build_type: Release
-          - os: heavy
             container:
               image: rippleci/clio_ci:latest
+          - os: heavy
             conan_profile: clang
             build_type: Release
-          - os: heavy
             container:
               image: rippleci/clio_ci:latest
+          - os: heavy
             conan_profile: clang
             build_type: Debug
+            container:
+              image: rippleci/clio_ci:latest
           - os: macos15
             conan_profile: apple_clang_16
             build_type: Release
-    runs-on: [self-hosted, "${{ matrix.os }}"]
+    runs-on: ${{ matrix.os }}
     container: ${{ matrix.container }}
 
     steps:
@@ -216,3 +127,44 @@ jobs:
         run: |
           chmod +x ./clio_tests
           ./clio_tests
+
+  check_config:
+    name: Check Config Description
+    needs: build
+    runs-on: heavy
+    container: 
+      image: rippleci/clio_ci:latest
+    steps:
+      - uses: actions/checkout@v4 
+      - uses: actions/download-artifact@v4
+        with:
+          name: clio_server_Linux_Release_gcc
+      - name: Compare Config Description
+        shell: bash
+        run: |
+          repoConfigFile=docs/config-description.md
+          if ! [ -f ${repoConfigFile} ]; then
+            echo "Config Description markdown file is missing in docs folder"
+            exit 1
+          fi
+
+          chmod +x ./clio_server
+          configDescriptionFile=config_description_new.md
+          ./clio_server -d ${configDescriptionFile}
+
+          configDescriptionHash=$(sha256sum ${configDescriptionFile} | cut -d' ' -f1)
+          repoConfigHash=$(sha256sum ${repoConfigFile} | cut -d' ' -f1)
+
+          if [ ${configDescriptionHash} != ${repoConfigHash} ]; then
+            echo "Markdown file is not up to date"
+            diff -u "${repoConfigFile}" "${configDescriptionFile}"
+            rm -f ${configDescriptionFile}
+            exit 1
+          fi
+          rm -f ${configDescriptionFile}
+          exit 0
+                    
+
+
+
+

.github/workflows/build_clio_docker_image.yml

@@ -40,7 +40,7 @@ on:
 jobs:
   build_and_publish_image:
     name: Build and publish image
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
 

.github/workflows/build_impl.yml

@@ -0,0 +1,192 @@
+name: Reusable build
+on:
+  workflow_call:
+    inputs:
+      runs_on:
+        description: Runner to run the job on
+        required: true
+        type: string
+        default: heavy
+
+      container:
+        description: "The container object as a JSON string (leave empty to run natively)"
+        required: true
+        type: string
+        default: ""
+
+      conan_profile:
+        description: Conan profile to use
+        required: true
+        type: string
+
+      build_type:
+        description: Build type
+        required: true
+        type: string
+
+      disable_cache:
+        description: Whether ccache and conan cache should be disabled
+        required: false
+        type: boolean
+        default: false
+
+      code_coverage:
+        description: Whether to enable code coverage
+        required: true
+        type: boolean
+        default: false
+
+      static:
+        description: Whether to build static binaries
+        required: true
+        type: boolean
+        default: true
+
+      unit_tests:
+        description: Whether to run unit tests
+        required: true
+        type: boolean
+        default: false
+
+      integration_tests:
+        description: Whether to run integration tests
+        required: true
+        type: boolean
+        default: false
+
+      clio_server:
+        description: Whether to build clio_server
+        required: true
+        type: boolean
+        default: true
+
+      target:
+        description: Build target name
+        required: false
+        type: string
+        default: all
+
+      sanitizer:
+        description: Sanitizer to use
+        required: false
+        type: string
+        default: 'false'
+
+jobs:
+  build:
+    name: Build ${{ inputs.container != '' && 'in container' || 'natively' }}
+    runs-on: ${{ inputs.runs_on }} 
+    container: ${{ inputs.container != '' && fromJson(inputs.container) || null }}
+
+    steps:
+      - name: Clean workdir
+        if: ${{ runner.os == 'macOS' }}
+        uses: kuznetsss/workspace-cleanup@1.0
+
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Prepare runner
+        uses: ./.github/actions/prepare_runner
+        with:
+          disable_ccache: ${{ inputs.disable_cache }}
+
+      - name: Setup conan
+        uses: ./.github/actions/setup_conan
+        id: conan
+        with:
+          conan_profile: ${{ inputs.conan_profile }}
+
+      - name: Restore cache
+        if: ${{ !inputs.disable_cache }}
+        uses: ./.github/actions/restore_cache
+        id: restore_cache
+        with:
+          conan_dir: ${{ env.CONAN_USER_HOME }}/.conan
+          conan_profile: ${{ steps.conan.outputs.conan_profile }}
+          ccache_dir: ${{ env.CCACHE_DIR }}
+          build_type: ${{ inputs.build_type }}
+          code_coverage: ${{ inputs.code_coverage }}
+
+      - name: Run conan and cmake
+        uses: ./.github/actions/generate
+        with:
+          conan_profile: ${{ steps.conan.outputs.conan_profile }}
+          conan_cache_hit: ${{ !inputs.disable_cache && steps.restore_cache.outputs.conan_cache_hit }}
+          build_type: ${{ inputs.build_type }}
+          code_coverage: ${{ inputs.code_coverage }}
+          static: ${{ inputs.static }}
+          sanitizer: ${{ inputs.sanitizer }}
+
+      - name: Build Clio
+        uses: ./.github/actions/build_clio
+        with:
+          target: ${{ inputs.target }}
+
+      - name: Show ccache's statistics
+        if: ${{ !inputs.disable_cache }}
+        shell: bash
+        id: ccache_stats
+        run: |
+          ccache -s > /tmp/ccache.stats
+          miss_rate=$(cat /tmp/ccache.stats | grep 'Misses' | head -n1 | sed 's/.*(\(.*\)%).*/\1/')
+          echo "miss_rate=${miss_rate}" >> $GITHUB_OUTPUT
+          cat /tmp/ccache.stats
+
+      - name: Strip unit_tests
+        if: ${{ inputs.unit_tests && !inputs.code_coverage && inputs.sanitizer == 'false' }}
+        run: strip build/clio_tests
+      
+      - name: Strip integration_tests
+        if: ${{ inputs.integration_tests && !inputs.code_coverage }}
+        run: strip build/clio_integration_tests
+
+      - name: Upload clio_server
+        if: ${{ inputs.clio_server }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: clio_server_${{ runner.os }}_${{ inputs.build_type }}_${{ steps.conan.outputs.conan_profile }}
+          path: build/clio_server
+     
+      - name: Upload clio_tests
+        if: ${{ inputs.unit_tests && !inputs.code_coverage }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: clio_tests_${{ runner.os }}_${{ inputs.build_type }}_${{ steps.conan.outputs.conan_profile }}
+          path: build/clio_tests
+      
+      - name: Upload clio_integration_tests
+        if: ${{ inputs.integration_tests && !inputs.code_coverage }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: clio_integration_tests_${{ runner.os }}_${{ inputs.build_type }}_${{ steps.conan.outputs.conan_profile }}
+          path: build/clio_integration_tests
+
+      - name: Save cache
+        if: ${{ !inputs.disable_cache && github.ref == 'refs/heads/develop' }}
+        uses: ./.github/actions/save_cache
+        with:
+          conan_dir: ${{ env.CONAN_USER_HOME }}/.conan
+          conan_hash: ${{ steps.restore_cache.outputs.conan_hash }}
+          conan_cache_hit: ${{ steps.restore_cache.outputs.conan_cache_hit }}
+          ccache_dir: ${{ env.CCACHE_DIR }}
+          ccache_cache_hit: ${{ steps.restore_cache.outputs.ccache_cache_hit }}
+          ccache_cache_miss_rate: ${{ steps.ccache_stats.outputs.miss_rate }}
+          build_type: ${{ inputs.build_type }}
+          code_coverage: ${{ inputs.code_coverage }}
+          conan_profile: ${{ steps.conan.outputs.conan_profile }}
+
+      # TODO: This is not a part of build process but it is the easiest way to do it here.
+      # It will be refactored in https://github.com/XRPLF/clio/issues/1075
+      - name: Run code coverage
+        if: ${{ inputs.code_coverage }}
+        uses: ./.github/actions/code_coverage
+
+  upload_coverage_report:
+    if: ${{ inputs.code_coverage }} 
+    name: Codecov
+    needs: build
+    uses: ./.github/workflows/upload_coverage_report.yml
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/check_libxrpl.yml

@@ -71,7 +71,7 @@ jobs:
     name: Create an issue on failure
     needs: [build, run_tests]
     if: ${{ always() && contains(needs.*.result, 'failure') }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     permissions:
       contents: write
       issues: write

.github/workflows/check_pr_title.yml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   check_title:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     # permissions:
     #   pull-requests: write
     steps:

.github/workflows/clang-tidy.yml

@@ -1,7 +1,7 @@
 name: Clang-tidy check
 on:
   schedule:
-    - cron: "0 6 * * 1-5"
+    - cron: "0 9 * * 1-5"
   workflow_dispatch:
   pull_request:
     branches: [develop]
@@ -12,7 +12,7 @@ on:
 
 jobs:
   clang_tidy:
-    runs-on: [self-hosted, Linux]
+    runs-on: heavy
     container:
       image: rippleci/clio_ci:latest
     permissions:

.github/workflows/clang-tidy_on_fix_merged.yml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   restart_clang_tidy:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
 
     permissions:
       actions: write

.github/workflows/docs.yml

@@ -18,7 +18,7 @@ jobs:
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     continue-on-error: true
     container:
       image: rippleci/clio_ci:latest

.github/workflows/nightly.yml

@@ -1,7 +1,7 @@
 name: Nightly release
 on:
   schedule:
-    - cron:  '0 5 * * 1-5'
+    - cron:  '0 8 * * 1-5'
   workflow_dispatch:
   pull_request:
     paths:
@@ -21,68 +21,23 @@ jobs:
           - os: heavy
             build_type: Release
             static: true
-            container:
-              image: rippleci/clio_ci:latest
+            container: '{ "image": "rippleci/clio_ci:latest" }'
           - os: heavy
             build_type: Debug
             static: true
-            container:
-              image: rippleci/clio_ci:latest
-    runs-on: [self-hosted, "${{ matrix.os }}"]
-    container: ${{ matrix.container }}
-
-    steps:
-      - name: Clean workdir
-        if: ${{ runner.os == 'macOS' }}
-        uses: kuznetsss/workspace-cleanup@1.0
-
-      - uses: actions/checkout@v4
-        with:
-            fetch-depth: 0
-
-      - name: Prepare runner
-        uses: ./.github/actions/prepare_runner
-        with:
-            disable_ccache: true
-
-      - name: Setup conan
-        uses: ./.github/actions/setup_conan
-        id: conan
-        with:
-          conan_profile: gcc
-
-      - name: Run conan and cmake
-        uses: ./.github/actions/generate
-        with:
-          conan_profile: ${{ steps.conan.outputs.conan_profile }}
-          conan_cache_hit: ${{ steps.restore_cache.outputs.conan_cache_hit }}
-          build_type: ${{ matrix.build_type }}
-          static: ${{ matrix.static }}
-
-      - name: Build Clio
-        uses: ./.github/actions/build_clio
-
-      - name: Strip tests
-        run: strip build/clio_tests && strip build/clio_integration_tests
-
-      - name: Upload clio_tests
-        uses: actions/upload-artifact@v4
-        with:
-          name: clio_tests_${{ runner.os }}_${{ matrix.build_type }}
-          path: build/clio_*tests
-
-      - name: Compress clio_server
-        shell: bash
-        run: |
-            cd build
-            tar czf ./clio_server_${{ runner.os }}_${{ matrix.build_type }}.tar.gz ./clio_server
-
-      - name: Upload clio_server
-        uses: actions/upload-artifact@v4
-        with:
-          name: clio_server_${{ runner.os }}_${{ matrix.build_type }}
-          path: build/clio_server_${{ runner.os }}_${{ matrix.build_type }}.tar.gz
-
+            container: '{ "image": "rippleci/clio_ci:latest" }'
+    uses: ./.github/workflows/build_impl.yml
+    with:
+      runs_on: ${{ matrix.os }}
+      container: ${{ matrix.container }}
+      conan_profile: gcc
+      build_type: ${{ matrix.build_type }}
+      code_coverage: false
+      static: ${{ matrix.static }}
+      unit_tests: true
+      integration_tests: true
+      clio_server: true
+      disable_cache: true
 
   run_tests:
     needs: build
@@ -91,14 +46,17 @@ jobs:
       matrix:
         include:
           - os: macos15
+            conan_profile: apple_clang_16
             build_type: Release
             integration_tests: false
           - os: heavy
+            conan_profile: gcc
             build_type: Release
             container:
               image: rippleci/clio_ci:latest
             integration_tests: true  
           - os: heavy
+            conan_profile: gcc
             build_type: Debug
             container:
               image: rippleci/clio_ci:latest
@@ -122,13 +80,17 @@ jobs:
 
       - uses: actions/download-artifact@v4
         with:
-          name: clio_tests_${{ runner.os }}_${{ matrix.build_type }}
+          name: clio_tests_${{ runner.os }}_${{ matrix.build_type }}_${{ matrix.conan_profile }}
 
       - name: Run clio_tests
         run: |
           chmod +x ./clio_tests
           ./clio_tests
   
+      - uses: actions/download-artifact@v4
+        with:
+          name: clio_integration_tests_${{ runner.os }}_${{ matrix.build_type }}_${{ matrix.conan_profile }}
+
   # To be enabled back once docker in mac runner arrives
   # https://github.com/XRPLF/clio/issues/1400
       - name: Run clio_integration_tests
@@ -140,7 +102,7 @@ jobs:
   nightly_release:
     if: ${{ github.event_name != 'pull_request' }}
     needs: run_tests
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     env:
       GH_REPO: ${{ github.repository }}
       GH_TOKEN: ${{ github.token }}
@@ -189,14 +151,14 @@ jobs:
       tags: |
           type=raw,value=nightly
           type=raw,value=${{ github.sha }}
-      artifact_name: clio_server_Linux_Release
+      artifact_name: clio_server_Linux_Release_gcc
       strip_binary: true
       publish_image: ${{ github.event_name != 'pull_request' }}
 
   create_issue_on_failure:
     needs: [build, run_tests, nightly_release, build_and_publish_docker_image]
     if: ${{ always() && contains(needs.*.result, 'failure') && github.event_name != 'pull_request' }}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     permissions:
       contents: write
       issues: write

.github/workflows/sanitizers.yml

@@ -0,0 +1,106 @@
+name: Run tests with sanitizers
+on:
+  schedule:
+    - cron: "0 4 * * 1-5"
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - '.github/workflows/sanitizers.yml'
+
+jobs:
+  build:
+    name: Build clio tests
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - sanitizer: tsan
+            compiler: gcc
+          - sanitizer: asan
+            compiler: gcc
+          # - sanitizer: ubsan # todo: enable when heavy runners are available
+          #   compiler: gcc
+    uses: ./.github/workflows/build_impl.yml
+    with:
+      runs_on: ubuntu-latest # todo: change to heavy
+      container: '{ "image": "rippleci/clio_ci:latest" }'
+      disable_cache: true
+      conan_profile: ${{ matrix.compiler }}.${{ matrix.sanitizer }}
+      build_type: Release
+      code_coverage: false
+      static: false
+      unit_tests: true
+      integration_tests: false
+      clio_server: false
+      target: clio_tests
+      sanitizer: ${{ matrix.sanitizer }}
+
+  # consider combining this with the previous matrix instead
+  run_tests:
+    needs: build
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - sanitizer: tsan
+            compiler: gcc
+          - sanitizer: asan
+            compiler: gcc
+          # - sanitizer: ubsan # todo: enable when heavy runners are available
+          #   compiler: gcc
+    runs-on: ubuntu-latest # todo: change to heavy
+    container:
+      image: rippleci/clio_ci:latest
+    permissions:
+      contents: write
+      issues: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: clio_tests_${{ runner.os }}_Release_${{ matrix.compiler }}.${{ matrix.sanitizer }}
+
+      - name: Run clio_tests [${{ matrix.compiler }} / ${{ matrix.sanitizer }}]
+        shell: bash
+        run: |
+          chmod +x ./clio_tests
+          ./.github/scripts/execute-tests-under-sanitizer ./clio_tests
+
+      - name: Check for sanitizer report
+        shell: bash
+        id: check_report
+        run: |
+          if ls .sanitizer-report/* 1> /dev/null 2>&1; then
+            echo "found_report=true" >> $GITHUB_OUTPUT
+          else
+            echo "found_report=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Upload report
+        if: ${{ steps.check_report.outputs.found_report == 'true' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.compiler }}_${{ matrix.sanitizer }}_report
+          path: .sanitizer-report/*
+          include-hidden-files: true
+
+      #
+      # todo: enable when we have fixed all currently existing issues from sanitizers
+      #
+      # - name: Create an issue
+      #   if: ${{ steps.check_report.outputs.found_report == 'true' }}
+      #   uses: ./.github/actions/create_issue
+      #   env:
+      #     GH_TOKEN: ${{ github.token }}
+      #   with:
+      #     labels: 'bug'
+      #     title: '[${{ matrix.sanitizer }}/${{ matrix.compiler }}] reported issues'
+      #     body: >
+      #       Clio tests failed one or more sanitizer checks when built with ${{ matrix.compiler }}`.
+
+      #       Workflow: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}/
+      #       Reports are available as artifacts.

.github/workflows/upload_coverage_report.yml

@@ -9,7 +9,7 @@ on:
 jobs:
   upload_report:
     name: Upload report
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
         with:

.gitignore

@@ -6,6 +6,7 @@
 .vscode
 .python-version
 .DS_Store
+.sanitizer-report
 CMakeUserPresets.json
 config.json
 src/util/build/Build.cpp

CMakeLists.txt

@@ -16,6 +16,8 @@ option(coverage "Build test coverage report" FALSE)
 option(packaging "Create distribution packages" FALSE)
 option(lint "Run clang-tidy checks during compilation" FALSE)
 option(static "Statically linked Clio" FALSE)
+option(snapshot "Build snapshot tool" FALSE)
+
 # ========================================================================== #
 set(san "" CACHE STRING "Add sanitizer instrumentation")
 set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
@@ -65,15 +67,21 @@ endif ()
 
 # Enable selected sanitizer if enabled via `san`
 if (san)
+  set(SUPPORTED_SANITIZERS "address" "thread" "memory" "undefined")
+  list(FIND SUPPORTED_SANITIZERS "${san}" INDEX)
+  if (INDEX EQUAL -1)
+    message(FATAL_ERROR "Error: Unsupported sanitizer '${san}'. Supported values are: ${SUPPORTED_SANITIZERS}.")
+  endif ()
+
   target_compile_options(
-    clio PUBLIC # Sanitizers recommend minimum of -O1 for reasonable performance
-                $<$<CONFIG:Debug>:-O1> ${SAN_FLAG} -fno-omit-frame-pointer
+    clio_options INTERFACE # Sanitizers recommend minimum of -O1 for reasonable performance
+                           $<$<CONFIG:Debug>:-O1> ${SAN_FLAG} -fno-omit-frame-pointer
   )
   target_compile_definitions(
-    clio PUBLIC $<$<STREQUAL:${san},address>:SANITIZER=ASAN> $<$<STREQUAL:${san},thread>:SANITIZER=TSAN>
-                $<$<STREQUAL:${san},memory>:SANITIZER=MSAN> $<$<STREQUAL:${san},undefined>:SANITIZER=UBSAN>
+    clio_options INTERFACE $<$<STREQUAL:${san},address>:SANITIZER=ASAN> $<$<STREQUAL:${san},thread>:SANITIZER=TSAN>
+                           $<$<STREQUAL:${san},memory>:SANITIZER=MSAN> $<$<STREQUAL:${san},undefined>:SANITIZER=UBSAN>
   )
-  target_link_libraries(clio INTERFACE ${SAN_FLAG} ${SAN_LIB})
+  target_link_libraries(clio_options INTERFACE ${SAN_FLAG} ${SAN_LIB})
 endif ()
 
 # Generate `docs` target for doxygen documentation if enabled Note: use `make docs` to generate the documentation
@@ -85,3 +93,7 @@ include(install/install)
 if (packaging)
   include(cmake/packaging.cmake) # This file exists only in build runner
 endif ()
+
+if (snapshot)
+  add_subdirectory(tools/snapshot)
+endif ()

cmake/Settings.cmake

@@ -39,6 +39,34 @@ if (is_appleclang)
   list(APPEND COMPILER_FLAGS -Wreorder-init-list)
 endif ()
 
+if (san)
+  # When building with sanitizers some compilers will actually produce extra warnings/errors. We don't want this yet, at
+  # least not until we have fixed all runtime issues reported by the sanitizers. Once that is done we can start removing
+  # some of these and trying to fix it in our codebase. We can never remove all of below because most of them are
+  # reported from deep inside libraries like boost or libxrpl.
+  #
+  # TODO: Address in https://github.com/XRPLF/clio/issues/1885
+  list(
+    APPEND
+    COMPILER_FLAGS
+    -Wno-error=tsan # Disables treating TSAN warnings as errors
+    -Wno-tsan # Disables TSAN warnings (thread-safety analysis)
+    -Wno-uninitialized # Disables warnings about uninitialized variables (AddressSanitizer, UndefinedBehaviorSanitizer,
+                       # etc.)
+    -Wno-stringop-overflow # Disables warnings about potential string operation overflows (AddressSanitizer)
+    -Wno-unsafe-buffer-usage # Disables warnings about unsafe memory operations (AddressSanitizer)
+    -Wno-frame-larger-than # Disables warnings about stack frame size being too large (AddressSanitizer)
+    -Wno-unused-function # Disables warnings about unused functions (LeakSanitizer, memory-related issues)
+    -Wno-unused-but-set-variable # Disables warnings about unused variables (MemorySanitizer)
+    -Wno-thread-safety-analysis # Disables warnings related to thread safety usage (ThreadSanitizer)
+    -Wno-thread-safety # Disables warnings related to thread safety usage (ThreadSanitizer)
+    -Wno-sign-compare # Disables warnings about signed/unsigned comparison (UndefinedBehaviorSanitizer)
+    -Wno-nonnull # Disables warnings related to null pointer dereferencing (UndefinedBehaviorSanitizer)
+    -Wno-address # Disables warnings about address-related issues (UndefinedBehaviorSanitizer)
+    -Wno-array-bounds # Disables array bounds checks (UndefinedBehaviorSanitizer)
+  )
+endif ()
+
 # See https://github.com/cpp-best-practices/cppbestpractices/blob/master/02-Use_the_Tools_Available.md#gcc--clang for
 # the flags description
 

cmake/deps/libbacktrace.cmake

@@ -1,3 +1,11 @@
-target_compile_definitions(clio_options INTERFACE BOOST_STACKTRACE_LINK)
-target_compile_definitions(clio_options INTERFACE BOOST_STACKTRACE_USE_BACKTRACE)
-find_package(libbacktrace REQUIRED CONFIG)
+if ("${san}" STREQUAL "")
+  target_compile_definitions(clio_options INTERFACE BOOST_STACKTRACE_LINK)
+  target_compile_definitions(clio_options INTERFACE BOOST_STACKTRACE_USE_BACKTRACE)
+  find_package(libbacktrace REQUIRED CONFIG)
+else ()
+  # Some sanitizers (TSAN and ASAN for sure) can't be used with libbacktrace because they have their own backtracing
+  # capabilities and there are conflicts. In any case, this makes sure Clio code knows that backtrace is not available.
+  # See relevant conan profiles for sanitizers where we disable stacktrace in Boost explicitly.
+  target_compile_definitions(clio_options INTERFACE CLIO_WITHOUT_STACKTRACE)
+  message(STATUS "Sanitizer enabled, disabling stacktrace")
+endif ()

conanfile.py

@@ -19,16 +19,17 @@ class Clio(ConanFile):
         'packaging': [True, False],           # create distribution packages
         'coverage': [True, False],            # build for test coverage report; create custom target `clio_tests-ccov`
         'lint': [True, False],                # run clang-tidy checks during compilation
+        'snapshot': [True, False],            # build export/import snapshot tool
     }
 
     requires = [
-        'boost/1.82.0',
+        'boost/1.83.0',
         'cassandra-cpp-driver/2.17.0',
         'fmt/10.1.1',
         'protobuf/3.21.9',
         'grpc/1.50.1',
-        'openssl/1.1.1u',
-        'xrpl/2.4.0-b3',
+        'openssl/1.1.1v',
+        'xrpl/2.4.0',
         'zlib/1.3.1',
         'libbacktrace/cci.20210118'
     ]
@@ -44,6 +45,7 @@ class Clio(ConanFile):
         'coverage': False,
         'lint': False,
         'docs': False,
+        'snapshot': False,
         
         'xrpl/*:tests': False,
         'xrpl/*:rocksdb': False,
@@ -92,6 +94,7 @@ class Clio(ConanFile):
         tc.variables['docs'] = self.options.docs
         tc.variables['packaging'] = self.options.packaging
         tc.variables['benchmark'] = self.options.benchmark
+        tc.variables['snapshot'] = self.options.snapshot
         tc.generate()
 
     def build(self):

docs/config-description.md

@@ -0,0 +1,452 @@
+# Clio Config Description
+This file lists all Clio Configuration definitions in detail.
+
+## Configuration Details
+
+### Key: database.type
+- **Required**: True
+- **Type**: string
+- **Default value**: cassandra
+- **Constraints**: The value must be one of the following: `cassandra`
+ -   **Description**: Type of database to use. We currently support Cassandra and Scylladb. We default to Scylladb.
+### Key: database.cassandra.contact_points
+- **Required**: True
+- **Type**: string
+- **Default value**: localhost
+- **Constraints**: None
+ -   **Description**: A list of IP addresses or hostnames of the initial nodes (Cassandra/Scylladb cluster nodes) that the client will connect to when establishing a connection with the database. If you're running locally, it should be 'localhost' or 127.0.0.1
+### Key: database.cassandra.secure_connect_bundle
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: Configuration file that contains the necessary security credentials and connection details for securely connecting to a Cassandra database cluster.
+### Key: database.cassandra.port
+- **Required**: False
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `1`. The maximum value is `65535
+ -   **Description**: Port number to connect to the database.
+### Key: database.cassandra.keyspace
+- **Required**: True
+- **Type**: string
+- **Default value**: clio
+- **Constraints**: None
+ -   **Description**: Keyspace to use for the database.
+### Key: database.cassandra.replication_factor
+- **Required**: True
+- **Type**: int
+- **Default value**: 3
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Number of replicated nodes for Scylladb. Visit this link for more details : https://university.scylladb.com/courses/scylla-essentials-overview/lessons/high-availability/topic/fault-tolerance-replication-factor/ 
+### Key: database.cassandra.table_prefix
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: Prefix for Database table names.
+### Key: database.cassandra.max_write_requests_outstanding
+- **Required**: True
+- **Type**: int
+- **Default value**: 10000
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Maximum number of outstanding write requests. Write requests are api calls that write to database 
+### Key: database.cassandra.max_read_requests_outstanding
+- **Required**: True
+- **Type**: int
+- **Default value**: 100000
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Maximum number of outstanding read requests, which reads from database
+### Key: database.cassandra.threads
+- **Required**: True
+- **Type**: int
+- **Default value**: The number of available CPU cores.
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Number of threads that will be used for database operations.
+### Key: database.cassandra.core_connections_per_host
+- **Required**: True
+- **Type**: int
+- **Default value**: 1
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Number of core connections per host for Cassandra.
+### Key: database.cassandra.queue_size_io
+- **Required**: False
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Queue size for I/O operations in Cassandra.
+### Key: database.cassandra.write_batch_size
+- **Required**: True
+- **Type**: int
+- **Default value**: 20
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Batch size for write operations in Cassandra.
+### Key: database.cassandra.connect_timeout
+- **Required**: False
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: The maximum amount of time in seconds the system will wait for a connection to be successfully established with the database.
+### Key: database.cassandra.request_timeout
+- **Required**: False
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: The maximum amount of time in seconds the system will wait for a request to be fetched from database.
+### Key: database.cassandra.username
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: The username used for authenticating with the database.
+### Key: database.cassandra.password
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: The password used for authenticating with the database.
+### Key: database.cassandra.certfile
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: The path to the SSL/TLS certificate file used to establish a secure connection between the client and the Cassandra database.
+### Key: allow_no_etl
+- **Required**: True
+- **Type**: boolean
+- **Default value**: True
+- **Constraints**: None
+ -   **Description**: If True, no ETL nodes will run with Clio.
+### Key: etl_sources.[].ip
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: The value must be a valid IP address
+ -   **Description**: IP address of the ETL source.
+### Key: etl_sources.[].ws_port
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: The minimum value is `1`. The maximum value is `65535
+ -   **Description**: WebSocket port of the ETL source.
+### Key: etl_sources.[].grpc_port
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: The minimum value is `1`. The maximum value is `65535
+ -   **Description**: gRPC port of the ETL source.
+### Key: forwarding.cache_timeout
+- **Required**: True
+- **Type**: double
+- **Default value**: 0
+- **Constraints**: The value must be a positive double number
+ -   **Description**: Timeout duration for the forwarding cache used in Rippled communication.
+### Key: forwarding.request_timeout
+- **Required**: True
+- **Type**: double
+- **Default value**: 10
+- **Constraints**: The value must be a positive double number
+ -   **Description**: Timeout duration for the forwarding request used in Rippled communication.
+### Key: rpc.cache_timeout
+- **Required**: True
+- **Type**: double
+- **Default value**: 0
+- **Constraints**: The value must be a positive double number
+ -   **Description**: Timeout duration for RPC requests.
+### Key: num_markers
+- **Required**: False
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `1`. The maximum value is `256`
+ -   **Description**: The number of markers is the number of coroutines to download the initial ledger
+### Key: dos_guard.whitelist.[]
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: List of IP addresses to whitelist for DOS protection.
+### Key: dos_guard.max_fetches
+- **Required**: True
+- **Type**: int
+- **Default value**: 1000000
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Maximum number of fetch operations allowed by DOS guard.
+### Key: dos_guard.max_connections
+- **Required**: True
+- **Type**: int
+- **Default value**: 20
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Maximum number of concurrent connections allowed by DOS guard.
+### Key: dos_guard.max_requests
+- **Required**: True
+- **Type**: int
+- **Default value**: 20
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Maximum number of requests allowed by DOS guard.
+### Key: dos_guard.sweep_interval
+- **Required**: True
+- **Type**: double
+- **Default value**: 1
+- **Constraints**: The value must be a positive double number
+ -   **Description**: Interval in seconds for DOS guard to sweep/clear its state.
+### Key: workers
+- **Required**: True
+- **Type**: int
+- **Default value**: The number of available CPU cores.
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Number of threads to process RPC requests.
+### Key: server.ip
+- **Required**: True
+- **Type**: string
+- **Default value**: None
+- **Constraints**: The value must be a valid IP address
+ -   **Description**: IP address of the Clio HTTP server.
+### Key: server.port
+- **Required**: True
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `1`. The maximum value is `65535
+ -   **Description**: Port number of the Clio HTTP server.
+### Key: server.max_queue_size
+- **Required**: True
+- **Type**: int
+- **Default value**: 0
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Maximum size of the server's request queue. Value of 0 is no limit.
+### Key: server.local_admin
+- **Required**: False
+- **Type**: boolean
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: Indicates if the server should run with admin privileges. Only one of local_admin or admin_password can be set.
+### Key: server.admin_password
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: Password for Clio admin-only APIs. Only one of local_admin or admin_password can be set.
+### Key: server.processing_policy
+- **Required**: True
+- **Type**: string
+- **Default value**: parallel
+- **Constraints**: The value must be one of the following: `parallel, sequent`
+ -   **Description**: Could be "sequent" or "parallel". For the sequent policy, requests from a single client 
+        connection are processed one by one, with the next request read only after the previous one is processed. For the parallel policy, Clio will accept
+         all requests and process them in parallel, sending a reply for each request as soon as it is ready.
+### Key: server.parallel_requests_limit
+- **Required**: False
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Optional parameter, used only if processing_strategy `parallel`. It limits the number of requests for a single client connection that are processed in parallel. If not specified, the limit is infinite.
+### Key: server.ws_max_sending_queue_size
+- **Required**: True
+- **Type**: int
+- **Default value**: 1500
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Maximum size of the websocket sending queue.
+### Key: prometheus.enabled
+- **Required**: True
+- **Type**: boolean
+- **Default value**: False
+- **Constraints**: None
+ -   **Description**: Enable or disable Prometheus metrics.
+### Key: prometheus.compress_reply
+- **Required**: True
+- **Type**: boolean
+- **Default value**: False
+- **Constraints**: None
+ -   **Description**: Enable or disable compression of Prometheus responses.
+### Key: io_threads
+- **Required**: True
+- **Type**: int
+- **Default value**: 2
+- **Constraints**: The minimum value is `1`. The maximum value is `65535`
+ -   **Description**: Number of I/O threads. Value cannot be less than 1
+### Key: subscription_workers
+- **Required**: True
+- **Type**: int
+- **Default value**: 1
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: The number of worker threads or processes that are responsible for managing and processing subscription-based tasks from rippled
+### Key: graceful_period
+- **Required**: True
+- **Type**: double
+- **Default value**: 10
+- **Constraints**: The value must be a positive double number
+ -   **Description**: Number of milliseconds server will wait to shutdown gracefully.
+### Key: cache.num_diffs
+- **Required**: True
+- **Type**: int
+- **Default value**: 32
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Number of diffs to cache. For more info, consult readme.md in etc
+### Key: cache.num_markers
+- **Required**: True
+- **Type**: int
+- **Default value**: 48
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Number of markers to cache.
+### Key: cache.num_cursors_from_diff
+- **Required**: True
+- **Type**: int
+- **Default value**: 0
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Num of cursors that are different.
+### Key: cache.num_cursors_from_account
+- **Required**: True
+- **Type**: int
+- **Default value**: 0
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Number of cursors from an account.
+### Key: cache.page_fetch_size
+- **Required**: True
+- **Type**: int
+- **Default value**: 512
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Page fetch size for cache operations.
+### Key: cache.load
+- **Required**: True
+- **Type**: string
+- **Default value**: async
+- **Constraints**: The value must be one of the following: `sync, async, none`
+ -   **Description**: Cache loading strategy ('sync' or 'async').
+### Key: log_channels.[].channel
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: The value must be one of the following: `General, WebServer, Backend, RPC, ETL, Subscriptions, Performance, Migration`
+ -   **Description**: Name of the log channel.'RPC', 'ETL', and 'Performance'
+### Key: log_channels.[].log_level
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: The value must be one of the following: `trace, debug, info, warning, error, fatal, count`
+ -   **Description**: Log level for the specific log channel.`warning`, `error`, `fatal`
+### Key: log_level
+- **Required**: True
+- **Type**: string
+- **Default value**: info
+- **Constraints**: The value must be one of the following: `trace, debug, info, warning, error, fatal, count`
+ -   **Description**: General logging level of Clio. This level will be applied to all log channels that do not have an explicitly defined logging level.
+### Key: log_format
+- **Required**: True
+- **Type**: string
+- **Default value**: %TimeStamp% (%SourceLocation%) [%ThreadID%] %Channel%:%Severity% %Message%
+- **Constraints**: None
+ -   **Description**: Format string for log messages.
+### Key: log_to_console
+- **Required**: True
+- **Type**: boolean
+- **Default value**: True
+- **Constraints**: None
+ -   **Description**: Enable or disable logging to console.
+### Key: log_directory
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: Directory path for log files.
+### Key: log_rotation_size
+- **Required**: True
+- **Type**: int
+- **Default value**: 2048
+- **Constraints**: The minimum value is `1`. The maximum value is `4294967295`
+ -   **Description**: Log rotation size in megabytes. When the log file reaches this particular size, a new log file starts.
+### Key: log_directory_max_size
+- **Required**: True
+- **Type**: int
+- **Default value**: 51200
+- **Constraints**: The minimum value is `1`. The maximum value is `4294967295`
+ -   **Description**: Maximum size of the log directory in megabytes.
+### Key: log_rotation_hour_interval
+- **Required**: True
+- **Type**: int
+- **Default value**: 12
+- **Constraints**: The minimum value is `1`. The maximum value is `4294967295`
+ -   **Description**: Interval in hours for log rotation. If the current log file reaches this value in logging, a new log file starts.
+### Key: log_tag_style
+- **Required**: True
+- **Type**: string
+- **Default value**: none
+- **Constraints**: The value must be one of the following: `int, uint, null, none, uuid`
+ -   **Description**: Style for log tags.
+### Key: extractor_threads
+- **Required**: True
+- **Type**: int
+- **Default value**: 1
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Number of extractor threads.
+### Key: read_only
+- **Required**: True
+- **Type**: boolean
+- **Default value**: True
+- **Constraints**: None
+ -   **Description**: Indicates if the server should have read-only privileges.
+### Key: txn_threshold
+- **Required**: True
+- **Type**: int
+- **Default value**: 0
+- **Constraints**: The minimum value is `0`. The maximum value is `65535`
+ -   **Description**: Transaction threshold value.
+### Key: start_sequence
+- **Required**: False
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Starting ledger index.
+### Key: finish_sequence
+- **Required**: False
+- **Type**: int
+- **Default value**: None
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: Ending ledger index.
+### Key: ssl_cert_file
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: Path to the SSL certificate file.
+### Key: ssl_key_file
+- **Required**: False
+- **Type**: string
+- **Default value**: None
+- **Constraints**: None
+ -   **Description**: Path to the SSL key file.
+### Key: api_version.default
+- **Required**: True
+- **Type**: int
+- **Default value**: 1
+- **Constraints**: The minimum value is `1`. The maximum value is `3`
+ -   **Description**: Default API version Clio will run on.
+### Key: api_version.min
+- **Required**: True
+- **Type**: int
+- **Default value**: 1
+- **Constraints**: The minimum value is `1`. The maximum value is `3`
+ -   **Description**: Minimum API version.
+### Key: api_version.max
+- **Required**: True
+- **Type**: int
+- **Default value**: 3
+- **Constraints**: The minimum value is `1`. The maximum value is `3`
+ -   **Description**: Maximum API version.
+### Key: migration.full_scan_threads
+- **Required**: True
+- **Type**: int
+- **Default value**: 2
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: The number of threads used to scan the table.
+### Key: migration.full_scan_jobs
+- **Required**: True
+- **Type**: int
+- **Default value**: 4
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: The number of coroutines used to scan the table.
+### Key: migration.cursors_per_job
+- **Required**: True
+- **Type**: int
+- **Default value**: 100
+- **Constraints**: The minimum value is `0`. The maximum value is `4294967295`
+ -   **Description**: The number of cursors each coroutine will scan.
+

docs/examples/infrastructure/README.md

@@ -1,5 +1,9 @@
 # Example of clio monitoring infrastructure
 
+> [!WARNING]
+> This is only an example of Grafana dashboard for Clio. It was created for demonstration purposes only and may contain errors.
+> Clio team would not recommend to relate on data from this dashboard or use it for monitoring your Clio instances.
+
 This directory contains an example of docker based infrastructure to collect and visualise metrics from clio.
 
 The structure of the directory:

docs/examples/infrastructure/grafana/clio_dashboard.json

@@ -20,7 +20,6 @@
   "graphTooltip": 0,
   "id": 1,
   "links": [],
-  "liveNow": false,
   "panels": [
     {
       "datasource": {
@@ -79,6 +78,7 @@
         "graphMode": "area",
         "justifyMode": "auto",
         "orientation": "auto",
+        "percentChangeColorMode": "standard",
         "reduceOptions": {
           "calcs": [
             "lastNotNull"
@@ -90,7 +90,7 @@
         "textMode": "auto",
         "wideLayout": true
       },
-      "pluginVersion": "10.4.0",
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -159,6 +159,7 @@
         "graphMode": "area",
         "justifyMode": "auto",
         "orientation": "auto",
+        "percentChangeColorMode": "standard",
         "reduceOptions": {
           "calcs": [
             "lastNotNull"
@@ -170,7 +171,7 @@
         "textMode": "auto",
         "wideLayout": true
       },
-      "pluginVersion": "10.4.0",
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -243,6 +244,7 @@
         "graphMode": "area",
         "justifyMode": "auto",
         "orientation": "auto",
+        "percentChangeColorMode": "standard",
         "reduceOptions": {
           "calcs": [
             "lastNotNull"
@@ -254,7 +256,7 @@
         "textMode": "auto",
         "wideLayout": true
       },
-      "pluginVersion": "10.4.0",
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -327,6 +329,7 @@
         "graphMode": "area",
         "justifyMode": "auto",
         "orientation": "auto",
+        "percentChangeColorMode": "standard",
         "reduceOptions": {
           "calcs": [
             "lastNotNull"
@@ -338,7 +341,7 @@
         "textMode": "auto",
         "wideLayout": true
       },
-      "pluginVersion": "10.4.0",
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -373,6 +376,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -435,6 +439,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -491,6 +496,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -552,6 +558,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -586,6 +593,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -647,6 +655,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -681,6 +690,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -742,6 +752,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -776,6 +787,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -837,6 +849,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -872,6 +885,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -934,6 +948,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -941,7 +956,7 @@
             "uid": "PBFA97CFB590B2093"
           },
           "editorMode": "code",
-          "expr": "rpc_method_duration_us{job=\"clio\"}",
+          "expr": "sum by (method) (increase(rpc_method_duration_us[$__interval]))\n / \n sum by (method,) (increase(rpc_method_total_number{status=\"finished\"}[$__interval]))",
           "instant": false,
           "legendFormat": "{{method}}",
           "range": true,
@@ -968,6 +983,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -1029,6 +1045,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -1063,6 +1080,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -1124,6 +1142,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -1158,6 +1177,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 10,
             "gradientMode": "none",
@@ -1223,7 +1243,7 @@
           "sort": "none"
         }
       },
-      "pluginVersion": "10.2.0",
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -1296,6 +1316,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -1357,6 +1378,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -1404,6 +1426,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -1465,6 +1488,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -1510,6 +1534,7 @@
             "axisLabel": "",
             "axisPlacement": "auto",
             "barAlignment": 0,
+            "barWidthFactor": 0.6,
             "drawStyle": "line",
             "fillOpacity": 0,
             "gradientMode": "none",
@@ -1572,6 +1597,7 @@
           "sort": "none"
         }
       },
+      "pluginVersion": "11.4.0",
       "targets": [
         {
           "datasource": {
@@ -1590,8 +1616,9 @@
       "type": "timeseries"
     }
   ],
+  "preload": false,
   "refresh": "5s",
-  "schemaVersion": 39,
+  "schemaVersion": 40,
   "tags": [],
   "templating": {
     "list": []

src/app/CliArgs.cpp

@@ -21,6 +21,7 @@
 
 #include "migration/MigrationApplication.hpp"
 #include "util/build/Build.hpp"
+#include "util/newconfig/ConfigDescription.hpp"
 
 #include <boost/program_options/options_description.hpp>
 #include <boost/program_options/parsers.hpp>
@@ -29,6 +30,7 @@
 #include <boost/program_options/variables_map.hpp>
 
 #include <cstdlib>
+#include <filesystem>
 #include <iostream>
 #include <string>
 #include <utility>
@@ -42,12 +44,13 @@ CliArgs::parse(int argc, char const* argv[])
     // clang-format off
     po::options_description description("Options");
     description.add_options()
-        ("help,h", "print help message and exit")
-        ("version,v", "print version and exit")
-        ("conf,c", po::value<std::string>()->default_value(kDEFAULT_CONFIG_PATH), "configuration file")
+        ("help,h", "Print help message and exit")
+        ("version,v", "Print version and exit")
+        ("conf,c", po::value<std::string>()->default_value(kDEFAULT_CONFIG_PATH), "Configuration file")
         ("ng-web-server,w", "Use ng-web-server")
-        ("migrate", po::value<std::string>(), "start migration helper")
+        ("migrate", po::value<std::string>(), "Start migration helper")
         ("verify", "Checks the validity of config values")
+        ("config-description,d", po::value<std::string>(), "Generate config description markdown file")
     ;
     // clang-format on
     po::positional_options_description positional;
@@ -67,6 +70,17 @@ CliArgs::parse(int argc, char const* argv[])
         return Action{Action::Exit{EXIT_SUCCESS}};
     }
 
+    if (parsed.count("config-description") != 0u) {
+        std::filesystem::path const filePath = parsed["config-description"].as<std::string>();
+
+        auto const res = util::config::ClioConfigDescription::generateConfigDescriptionToFile(filePath);
+        if (res.has_value())
+            return Action{Action::Exit{EXIT_SUCCESS}};
+
+        std::cerr << res.error().error << std::endl;
+        return Action{Action::Exit{EXIT_FAILURE}};
+    }
+
     auto configPath = parsed["conf"].as<std::string>();
 
     if (parsed.count("migrate") != 0u) {

src/app/ClioApplication.cpp

@@ -23,9 +23,12 @@
 #include "app/WebHandlers.hpp"
 #include "data/AmendmentCenter.hpp"
 #include "data/BackendFactory.hpp"
+#include "data/LedgerCache.hpp"
 #include "etl/ETLService.hpp"
 #include "etl/LoadBalancer.hpp"
 #include "etl/NetworkValidatedLedgers.hpp"
+#include "etlng/LoadBalancer.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "feed/SubscriptionManager.hpp"
 #include "migration/MigrationInspectorFactory.hpp"
 #include "rpc/Counters.hpp"
@@ -41,6 +44,7 @@
 #include "web/Server.hpp"
 #include "web/dosguard/DOSGuard.hpp"
 #include "web/dosguard/IntervalSweepHandler.hpp"
+#include "web/dosguard/Weights.hpp"
 #include "web/dosguard/WhitelistHandler.hpp"
 #include "web/ng/RPCServerHandler.hpp"
 #include "web/ng/Server.hpp"
@@ -100,11 +104,15 @@ ClioApplication::run(bool const useNgWebServer)
 
     // Rate limiter, to prevent abuse
     auto whitelistHandler = web::dosguard::WhitelistHandler{config_};
-    auto dosGuard = web::dosguard::DOSGuard{config_, whitelistHandler};
+    auto const dosguardWeights = web::dosguard::Weights::make(config_);
+    auto dosGuard = web::dosguard::DOSGuard{config_, whitelistHandler, dosguardWeights};
     auto sweepHandler = web::dosguard::IntervalSweepHandler{config_, ioc, dosGuard};
+    auto cache = data::LedgerCache{};
 
     // Interface to the database
-    auto backend = data::makeBackend(config_);
+    auto backend = data::makeBackend(config_, cache);
+
+    auto const amendmentCenter = std::make_shared<data::AmendmentCenter const>(backend);
 
     {
         auto const migrationInspector = migration::makeMigrationInspector(config_, backend);
@@ -117,7 +125,7 @@ ClioApplication::run(bool const useNgWebServer)
     }
 
     // Manages clients subscribed to streams
-    auto subscriptions = feed::SubscriptionManager::makeSubscriptionManager(config_, backend);
+    auto subscriptions = feed::SubscriptionManager::makeSubscriptionManager(config_, backend, amendmentCenter);
 
     // Tracks which ledgers have been validated by the network
     auto ledgers = etl::NetworkValidatedLedgers::makeValidatedLedgers();
@@ -126,24 +134,29 @@ ClioApplication::run(bool const useNgWebServer)
     // ETL uses the balancer to extract data.
     // The server uses the balancer to forward RPCs to a rippled node.
     // The balancer itself publishes to streams (transactions_proposed and accounts_proposed)
-    auto balancer = etl::LoadBalancer::makeLoadBalancer(config_, ioc, backend, subscriptions, ledgers);
+    auto balancer = [&] -> std::shared_ptr<etlng::LoadBalancerInterface> {
+        if (config_.get<bool>("__ng_etl"))
+            return etlng::LoadBalancer::makeLoadBalancer(config_, ioc, backend, subscriptions, ledgers);
+
+        return etl::LoadBalancer::makeLoadBalancer(config_, ioc, backend, subscriptions, ledgers);
+    }();
 
     // ETL is responsible for writing and publishing to streams. In read-only mode, ETL only publishes
     auto etl = etl::ETLService::makeETLService(config_, ioc, backend, subscriptions, balancer, ledgers);
 
     auto workQueue = rpc::WorkQueue::makeWorkQueue(config_);
     auto counters = rpc::Counters::makeCounters(workQueue);
-    auto const amendmentCenter = std::make_shared<data::AmendmentCenter const>(backend);
+
     auto const handlerProvider = std::make_shared<rpc::impl::ProductionHandlerProvider const>(
         config_, backend, subscriptions, balancer, etl, amendmentCenter, counters
     );
 
-    using RPCEngineType = rpc::RPCEngine<etl::LoadBalancer, rpc::Counters>;
+    using RPCEngineType = rpc::RPCEngine<rpc::Counters>;
     auto const rpcEngine =
         RPCEngineType::makeRPCEngine(config_, backend, balancer, dosGuard, workQueue, counters, handlerProvider);
 
     if (useNgWebServer or config_.get<bool>("server.__ng_web_server")) {
-        web::ng::RPCServerHandler<RPCEngineType, etl::ETLService> handler{config_, backend, rpcEngine, etl};
+        web::ng::RPCServerHandler<RPCEngineType> handler{config_, backend, rpcEngine, etl, dosGuard};
 
         auto expectedAdminVerifier = web::makeAdminVerificationStrategy(config_);
         if (not expectedAdminVerifier.has_value()) {
@@ -161,7 +174,7 @@ ClioApplication::run(bool const useNgWebServer)
 
         httpServer->onGet("/metrics", MetricsHandler{adminVerifier});
         httpServer->onGet("/health", HealthCheckHandler{});
-        auto requestHandler = RequestHandler{adminVerifier, handler, dosGuard};
+        auto requestHandler = RequestHandler{adminVerifier, handler};
         httpServer->onPost("/", requestHandler);
         httpServer->onWs(std::move(requestHandler));
 
@@ -184,8 +197,7 @@ ClioApplication::run(bool const useNgWebServer)
     }
 
     // Init the web server
-    auto handler =
-        std::make_shared<web::RPCServerHandler<RPCEngineType, etl::ETLService>>(config_, backend, rpcEngine, etl);
+    auto handler = std::make_shared<web::RPCServerHandler<RPCEngineType>>(config_, backend, rpcEngine, etl, dosGuard);
 
     auto const httpServer = web::makeHttpServer(config_, ioc, dosGuard, handler);
 

src/app/Stopper.hpp

@@ -20,8 +20,8 @@
 #pragma once
 
 #include "data/BackendInterface.hpp"
-#include "etl/ETLService.hpp"
-#include "etl/LoadBalancer.hpp"
+#include "etlng/ETLServiceInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
 #include "util/CoroutineGroup.hpp"
 #include "util/log/Logger.hpp"
@@ -74,15 +74,12 @@ public:
      * @param ioc The io_context to stop.
      * @return The callback to be called on application stop.
      */
-    template <
-        web::ng::SomeServer ServerType,
-        etl::SomeLoadBalancer LoadBalancerType,
-        etl::SomeETLService ETLServiceType>
+    template <web::ng::SomeServer ServerType>
     static std::function<void(boost::asio::yield_context)>
     makeOnStopCallback(
         ServerType& server,
-        LoadBalancerType& balancer,
-        ETLServiceType& etl,
+        etlng::LoadBalancerInterface& balancer,
+        etlng::ETLServiceInterface& etl,
         feed::SubscriptionManagerInterface& subscriptions,
         data::BackendInterface& backend,
         boost::asio::io_context& ioc

src/app/WebHandlers.hpp

@@ -147,7 +147,6 @@ class RequestHandler {
     util::Logger webServerLog_{"WebServer"};
     std::shared_ptr<web::AdminVerificationStrategy> adminVerifier_;
     std::reference_wrapper<RpcHandlerType> rpcHandler_;
-    std::reference_wrapper<web::dosguard::DOSGuardInterface> dosguard_;
 
 public:
     /**
@@ -155,14 +154,9 @@ public:
      *
      * @param adminVerifier The AdminVerificationStrategy to use for verifying the connection for admin access.
      * @param rpcHandler The RPC handler to use for handling the request.
-     * @param dosguard The DOSGuardInterface to use for checking the connection.
      */
-    RequestHandler(
-        std::shared_ptr<web::AdminVerificationStrategy> adminVerifier,
-        RpcHandlerType& rpcHandler,
-        web::dosguard::DOSGuardInterface& dosguard
-    )
-        : adminVerifier_(std::move(adminVerifier)), rpcHandler_(rpcHandler), dosguard_(dosguard)
+    RequestHandler(std::shared_ptr<web::AdminVerificationStrategy> adminVerifier, RpcHandlerType& rpcHandler)
+        : adminVerifier_(std::move(adminVerifier)), rpcHandler_(rpcHandler)
     {
     }
 
@@ -183,21 +177,6 @@ public:
         boost::asio::yield_context yield
     )
     {
-        if (not dosguard_.get().request(connectionMetadata.ip())) {
-            auto error = rpc::makeError(rpc::RippledError::rpcSLOW_DOWN);
-
-            if (not request.isHttp()) {
-                try {
-                    auto requestJson = boost::json::parse(request.message());
-                    if (requestJson.is_object() && requestJson.as_object().contains("id"))
-                        error["id"] = requestJson.as_object().at("id");
-                    error["request"] = request.message();
-                } catch (std::exception const&) {
-                    error["request"] = request.message();
-                }
-            }
-            return web::ng::Response{boost::beast::http::status::service_unavailable, error, request};
-        }
         LOG(webServerLog_.info()) << connectionMetadata.tag()
                                   << "Received request from ip = " << connectionMetadata.ip()
                                   << " - posting to WorkQueue";
@@ -207,20 +186,7 @@ public:
         });
 
         try {
-            auto response = rpcHandler_(request, connectionMetadata, std::move(subscriptionContext), yield);
-
-            if (not dosguard_.get().add(connectionMetadata.ip(), response.message().size())) {
-                auto jsonResponse = boost::json::parse(response.message()).as_object();
-                jsonResponse["warning"] = "load";
-                if (jsonResponse.contains("warnings") && jsonResponse["warnings"].is_array()) {
-                    jsonResponse["warnings"].as_array().push_back(rpc::makeWarning(rpc::WarnRpcRateLimit));
-                } else {
-                    jsonResponse["warnings"] = boost::json::array{rpc::makeWarning(rpc::WarnRpcRateLimit)};
-                }
-                response.setMessage(jsonResponse);
-            }
-
-            return response;
+            return rpcHandler_(request, connectionMetadata, std::move(subscriptionContext), yield);
         } catch (std::exception const&) {
             return web::ng::Response{
                 boost::beast::http::status::internal_server_error,

src/data/AmendmentCenter.hpp

@@ -134,6 +134,9 @@ struct Amendments {
     REGISTER(Credentials);
     REGISTER(DynamicNFT);
     REGISTER(PermissionedDomains);
+    REGISTER(fixInvalidTxFlags);
+    REGISTER(fixFrozenLPTokenTransfer);
+    REGISTER(DeepFreeze);
 
     // Obsolete but supported by libxrpl
     REGISTER(CryptoConditionsSuite);

src/data/BackendFactory.hpp

@@ -21,6 +21,7 @@
 
 #include "data/BackendInterface.hpp"
 #include "data/CassandraBackend.hpp"
+#include "data/LedgerCacheInterface.hpp"
 #include "data/cassandra/SettingsProvider.hpp"
 #include "util/log/Logger.hpp"
 #include "util/newconfig/ConfigDefinition.hpp"
@@ -38,10 +39,11 @@ namespace data {
  * @brief A factory function that creates the backend based on a config.
  *
  * @param config The clio config to use
+ * @param cache The ledger cache to use
  * @return A shared_ptr<BackendInterface> with the selected implementation
  */
 inline std::shared_ptr<BackendInterface>
-makeBackend(util::config::ClioConfigDefinition const& config)
+makeBackend(util::config::ClioConfigDefinition const& config, data::LedgerCacheInterface& cache)
 {
     static util::Logger const log{"Backend"};  // NOLINT(readability-identifier-naming)
     LOG(log.info()) << "Constructing BackendInterface";
@@ -53,7 +55,9 @@ makeBackend(util::config::ClioConfigDefinition const& config)
 
     if (boost::iequals(type, "cassandra")) {
         auto const cfg = config.getObject("database." + type);
-        backend = std::make_shared<data::cassandra::CassandraBackend>(data::cassandra::SettingsProvider{cfg}, readOnly);
+        backend = std::make_shared<data::cassandra::CassandraBackend>(
+            data::cassandra::SettingsProvider{cfg}, cache, readOnly
+        );
     }
 
     if (!backend)

src/data/BackendInterface.cpp

@@ -87,7 +87,7 @@ BackendInterface::fetchLedgerObject(
     boost::asio::yield_context yield
 ) const
 {
-    auto obj = cache_.get(key, sequence);
+    auto obj = cache_.get().get(key, sequence);
     if (obj) {
         LOG(gLog.trace()) << "Cache hit - " << ripple::strHex(key);
         return obj;
@@ -126,7 +126,7 @@ BackendInterface::fetchLedgerObjects(
     results.resize(keys.size());
     std::vector<ripple::uint256> misses;
     for (size_t i = 0; i < keys.size(); ++i) {
-        auto obj = cache_.get(keys[i], sequence);
+        auto obj = cache_.get().get(keys[i], sequence);
         if (obj) {
             results[i] = *obj;
         } else {
@@ -156,7 +156,7 @@ BackendInterface::fetchSuccessorKey(
     boost::asio::yield_context yield
 ) const
 {
-    auto succ = cache_.getSuccessor(key, ledgerSequence);
+    auto succ = cache_.get().getSuccessor(key, ledgerSequence);
     if (succ) {
         LOG(gLog.trace()) << "Cache hit - " << ripple::strHex(key);
     } else {

src/data/BackendInterface.hpp

@@ -20,7 +20,7 @@
 #pragma once
 
 #include "data/DBHelpers.hpp"
-#include "data/LedgerCache.hpp"
+#include "data/LedgerCacheInterface.hpp"
 #include "data/Types.hpp"
 #include "etl/CorruptionDetector.hpp"
 #include "util/log/Logger.hpp"
@@ -40,6 +40,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <exception>
+#include <functional>
 #include <optional>
 #include <shared_mutex>
 #include <string>
@@ -139,18 +140,27 @@ class BackendInterface {
 protected:
     mutable std::shared_mutex rngMtx_;
     std::optional<LedgerRange> range_;
-    LedgerCache cache_;
-    std::optional<etl::CorruptionDetector<LedgerCache>> corruptionDetector_;
+    std::reference_wrapper<LedgerCacheInterface> cache_;
+    std::optional<etl::CorruptionDetector> corruptionDetector_;
 
 public:
-    BackendInterface() = default;
+    /**
+     * @brief Construct a new backend interface instance.
+     *
+     * @param cache The ledger cache to use
+     */
+    BackendInterface(LedgerCacheInterface& cache) : cache_{cache}
+    {
+    }
     virtual ~BackendInterface() = default;
 
-    // TODO: Remove this hack. Cache should not be exposed thru BackendInterface
+    // TODO https://github.com/XRPLF/clio/issues/1956: Remove this hack once old ETL is removed.
+    // Cache should not be exposed thru BackendInterface
+
     /**
      * @return Immutable cache
      */
-    LedgerCache const&
+    LedgerCacheInterface const&
     cache() const
     {
         return cache_;
@@ -159,7 +169,7 @@ public:
     /**
      * @return Mutable cache
      */
-    LedgerCache&
+    LedgerCacheInterface&
     cache()
     {
         return cache_;
@@ -171,7 +181,7 @@ public:
      * @param detector The corruption detector to set
      */
     void
-    setCorruptionDetector(etl::CorruptionDetector<LedgerCache> detector)
+    setCorruptionDetector(etl::CorruptionDetector detector)
     {
         corruptionDetector_ = std::move(detector);
     }
@@ -638,6 +648,14 @@ public:
     virtual void
     writeAccountTransactions(std::vector<AccountTransactionsData> data) = 0;
 
+    /**
+     * @brief Write a new account transaction.
+     *
+     * @param record An object representing the account transaction
+     */
+    virtual void
+    writeAccountTransaction(AccountTransactionsData record) = 0;
+
     /**
      * @brief Write NFTs transactions.
      *

src/data/CassandraBackend.hpp

@@ -21,6 +21,7 @@
 
 #include "data/BackendInterface.hpp"
 #include "data/DBHelpers.hpp"
+#include "data/LedgerCacheInterface.hpp"
 #include "data/Types.hpp"
 #include "data/cassandra/Concepts.hpp"
 #include "data/cassandra/Handle.hpp"
@@ -36,6 +37,7 @@
 #include <boost/asio/spawn.hpp>
 #include <boost/json/object.hpp>
 #include <cassandra.h>
+#include <fmt/core.h>
 #include <xrpl/basics/Blob.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/strHex.h>
@@ -44,6 +46,7 @@
 #include <xrpl/protocol/LedgerHeader.h>
 #include <xrpl/protocol/nft.h>
 
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <cstddef>
@@ -87,10 +90,12 @@ public:
      * @brief Create a new cassandra/scylla backend instance.
      *
      * @param settingsProvider The settings provider to use
+     * @param cache The ledger cache to use
      * @param readOnly Whether the database should be in readonly mode
      */
-    BasicCassandraBackend(SettingsProviderType settingsProvider, bool readOnly)
-        : settingsProvider_{std::move(settingsProvider)}
+    BasicCassandraBackend(SettingsProviderType settingsProvider, data::LedgerCacheInterface& cache, bool readOnly)
+        : BackendInterface(cache)
+        , settingsProvider_{std::move(settingsProvider)}
         , schema_{settingsProvider_}
         , handle_{settingsProvider_.getSettings()}
         , executor_{settingsProvider_.getSettings(), handle_}
@@ -113,13 +118,24 @@ public:
         try {
             schema_.prepareStatements(handle_);
         } catch (std::runtime_error const& ex) {
-            LOG(log_.error()) << "Failed to prepare the statements: " << ex.what() << "; readOnly: " << readOnly;
-            throw;
+            auto const error = fmt::format(
+                "Failed to prepare the statements: {}; readOnly: {}. ReadOnly should be turned off or another Clio "
+                "node with write access to DB should be started first.",
+                ex.what(),
+                readOnly
+            );
+            LOG(log_.error()) << error;
+            throw std::runtime_error(error);
         }
 
         LOG(log_.info()) << "Created (revamped) CassandraBackend";
     }
 
+    /*
+     * @brief Move constructor is deleted because handle_ is shared by reference with executor
+     */
+    BasicCassandraBackend(BasicCassandraBackend&&) = delete;
+
     TransactionsAndCursor
     fetchAccountTransactions(
         ripple::AccountID const& account,
@@ -891,30 +907,42 @@ public:
         statements.reserve(data.size() * 10);  // assume 10 transactions avg
 
         for (auto& record : data) {
-            std::transform(
-                std::begin(record.accounts),
-                std::end(record.accounts),
-                std::back_inserter(statements),
-                [this, &record](auto&& account) {
-                    return schema_->insertAccountTx.bind(
-                        std::forward<decltype(account)>(account),
-                        std::make_tuple(record.ledgerSequence, record.transactionIndex),
-                        record.txHash
-                    );
-                }
-            );
+            std::ranges::transform(record.accounts, std::back_inserter(statements), [this, &record](auto&& account) {
+                return schema_->insertAccountTx.bind(
+                    std::forward<decltype(account)>(account),
+                    std::make_tuple(record.ledgerSequence, record.transactionIndex),
+                    record.txHash
+                );
+            });
         }
 
         executor_.write(std::move(statements));
     }
 
+    void
+    writeAccountTransaction(AccountTransactionsData record) override
+    {
+        std::vector<Statement> statements;
+        statements.reserve(record.accounts.size());
+
+        std::ranges::transform(record.accounts, std::back_inserter(statements), [this, &record](auto&& account) {
+            return schema_->insertAccountTx.bind(
+                std::forward<decltype(account)>(account),
+                std::make_tuple(record.ledgerSequence, record.transactionIndex),
+                record.txHash
+            );
+        });
+
+        executor_.write(std::move(statements));
+    }
+
     void
     writeNFTTransactions(std::vector<NFTTransactionsData> const& data) override
     {
         std::vector<Statement> statements;
         statements.reserve(data.size());
 
-        std::transform(std::cbegin(data), std::cend(data), std::back_inserter(statements), [this](auto const& record) {
+        std::ranges::transform(data, std::back_inserter(statements), [this](auto const& record) {
             return schema_->insertNFTTx.bind(
                 record.tokenID, std::make_tuple(record.ledgerSequence, record.transactionIndex), record.txHash
             );
@@ -984,7 +1012,7 @@ public:
         std::vector<Statement> statements;
         statements.reserve(data.size());
         for (auto [mptId, holder] : data)
-            statements.push_back(schema_->insertMPTHolder.bind(std::move(mptId), std::move(holder)));
+            statements.push_back(schema_->insertMPTHolder.bind(mptId, holder));
 
         executor_.write(std::move(statements));
     }

src/data/DBHelpers.hpp

@@ -54,7 +54,7 @@ struct AccountTransactionsData {
      * @param meta The transaction metadata
      * @param txHash The transaction hash
      */
-    AccountTransactionsData(ripple::TxMeta& meta, ripple::uint256 const& txHash)
+    AccountTransactionsData(ripple::TxMeta const& meta, ripple::uint256 const& txHash)
         : accounts(meta.getAffectedAccounts())
         , ledgerSequence(meta.getLgrSeq())
         , transactionIndex(meta.getIndex())

src/data/LedgerCache.cpp

@@ -20,6 +20,7 @@
 #include "data/LedgerCache.hpp"
 
 #include "data/Types.hpp"
+#include "etlng/Models.hpp"
 #include "util/Assert.hpp"
 
 #include <xrpl/basics/base_uint.h>
@@ -87,6 +88,42 @@ LedgerCache::update(std::vector<LedgerObject> const& objs, uint32_t seq, bool is
     }
 }
 
+void
+LedgerCache::update(std::vector<etlng::model::Object> const& objs, uint32_t seq)
+{
+    if (disabled_)
+        return;
+
+    std::scoped_lock const lck{mtx_};
+    if (seq > latestSeq_) {
+        ASSERT(
+            seq == latestSeq_ + 1 || latestSeq_ == 0,
+            "New sequence must be either next or first. seq = {}, latestSeq_ = {}",
+            seq,
+            latestSeq_
+        );
+        latestSeq_ = seq;
+    }
+
+    deleted_.clear();  // previous update's deletes no longer needed
+
+    for (auto const& obj : objs) {
+        if (!obj.data.empty()) {
+            auto& e = map_[obj.key];
+            if (seq > e.seq)
+                e = {.seq = seq, .blob = obj.data};
+        } else {
+            if (map_.contains(obj.key))
+                deleted_[obj.key] = map_[obj.key];
+
+            map_.erase(obj.key);
+            if (!full_)
+                deletes_.insert(obj.key);
+        }
+    }
+    cv_.notify_all();
+}
+
 std::optional<LedgerObject>
 LedgerCache::getSuccessor(ripple::uint256 const& key, uint32_t seq) const
 {
@@ -139,6 +176,29 @@ LedgerCache::get(ripple::uint256 const& key, uint32_t seq) const
     return {e->second.blob};
 }
 
+std::optional<Blob>
+LedgerCache::getDeleted(ripple::uint256 const& key, uint32_t seq) const
+{
+    if (disabled_)
+        return std::nullopt;
+
+    std::shared_lock const lck{mtx_};
+    if (seq > latestSeq_)
+        return std::nullopt;
+
+    ++objectReqCounter_.get();
+
+    auto e = deleted_.find(key);
+    if (e == deleted_.end())
+        return std::nullopt;
+
+    if (seq < e->second.seq)
+        return std::nullopt;
+
+    ++objectHitCounter_.get();
+    return {e->second.blob};
+}
+
 void
 LedgerCache::setDisabled()
 {

src/data/LedgerCache.hpp

@@ -19,7 +19,10 @@
 
 #pragma once
 
+#include "data/LedgerCacheInterface.hpp"
 #include "data/Types.hpp"
+#include "etlng/Models.hpp"
+#include "util/prometheus/Bool.hpp"
 #include "util/prometheus/Counter.hpp"
 #include "util/prometheus/Label.hpp"
 #include "util/prometheus/Prometheus.hpp"
@@ -27,7 +30,6 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/hardened_hash.h>
 
-#include <atomic>
 #include <condition_variable>
 #include <cstddef>
 #include <cstdint>
@@ -43,7 +45,7 @@ namespace data {
 /**
  * @brief Cache for an entire ledger.
  */
-class LedgerCache {
+class LedgerCache : public LedgerCacheInterface {
     struct CacheEntry {
         uint32_t seq = 0;
         Blob blob;
@@ -72,120 +74,70 @@ class LedgerCache {
     )};
 
     std::map<ripple::uint256, CacheEntry> map_;
+    std::map<ripple::uint256, CacheEntry> deleted_;
 
     mutable std::shared_mutex mtx_;
     std::condition_variable_any cv_;
     uint32_t latestSeq_ = 0;
-    std::atomic_bool full_ = false;
-    std::atomic_bool disabled_ = false;
+    util::prometheus::Bool full_{PrometheusService::boolMetric(
+        "ledger_cache_full",
+        util::prometheus::Labels{},
+        "Whether ledger cache full or not"
+    )};
+    util::prometheus::Bool disabled_{PrometheusService::boolMetric(
+        "ledger_cache_disabled",
+        util::prometheus::Labels{},
+        "Whether ledger cache is disabled or not"
+    )};
 
     // temporary set to prevent background thread from writing already deleted data. not used when cache is full
     std::unordered_set<ripple::uint256, ripple::hardened_hash<>> deletes_;
 
 public:
-    /**
-     * @brief Update the cache with new ledger objects.
-     *
-     * @param objs The ledger objects to update cache with
-     * @param seq The sequence to update cache for
-     * @param isBackground Should be set to true when writing old data from a background thread
-     */
     void
-    update(std::vector<LedgerObject> const& objs, uint32_t seq, bool isBackground = false);
+    update(std::vector<LedgerObject> const& objs, uint32_t seq, bool isBackground) override;
+
+    void
+    update(std::vector<etlng::model::Object> const& objs, uint32_t seq) override;
 
-    /**
-     * @brief Fetch a cached object by its key and sequence number.
-     *
-     * @param key The key to fetch for
-     * @param seq The sequence to fetch for
-     * @return If found in cache, will return the cached Blob; otherwise nullopt is returned
-     */
     std::optional<Blob>
-    get(ripple::uint256 const& key, uint32_t seq) const;
+    get(ripple::uint256 const& key, uint32_t seq) const override;
+
+    std::optional<Blob>
+    getDeleted(ripple::uint256 const& key, uint32_t seq) const override;
 
-    /**
-     * @brief Gets a cached successor.
-     *
-     * Note: This function always returns std::nullopt when @ref isFull() returns false.
-     *
-     * @param key The key to fetch for
-     * @param seq The sequence to fetch for
-     * @return If found in cache, will return the cached successor; otherwise nullopt is returned
-     */
     std::optional<LedgerObject>
-    getSuccessor(ripple::uint256 const& key, uint32_t seq) const;
+    getSuccessor(ripple::uint256 const& key, uint32_t seq) const override;
 
-    /**
-     * @brief Gets a cached predcessor.
-     *
-     * Note: This function always returns std::nullopt when @ref isFull() returns false.
-     *
-     * @param key The key to fetch for
-     * @param seq The sequence to fetch for
-     * @return If found in cache, will return the cached predcessor; otherwise nullopt is returned
-     */
     std::optional<LedgerObject>
-    getPredecessor(ripple::uint256 const& key, uint32_t seq) const;
+    getPredecessor(ripple::uint256 const& key, uint32_t seq) const override;
 
-    /**
-     * @brief Disables the cache.
-     */
     void
-    setDisabled();
+    setDisabled() override;
 
-    /**
-     * @return true if the cache is disabled; false otherwise
-     */
     bool
-    isDisabled() const;
+    isDisabled() const override;
 
-    /**
-     * @brief Sets the full flag to true.
-     *
-     * This is used when cache loaded in its entirety at startup of the application. This can be either loaded from DB,
-     * populated together with initial ledger download (on first run) or downloaded from a peer node (specified in
-     * config).
-     */
     void
-    setFull();
+    setFull() override;
 
-    /**
-     * @return The latest ledger sequence for which cache is available.
-     */
     uint32_t
-    latestLedgerSequence() const;
+    latestLedgerSequence() const override;
 
-    /**
-     * @return true if the cache has all data for the most recent ledger; false otherwise
-     */
     bool
-    isFull() const;
+    isFull() const override;
 
-    /**
-     * @return The total size of the cache.
-     */
     size_t
-    size() const;
+    size() const override;
 
-    /**
-     * @return A number representing the success rate of hitting an object in the cache versus missing it.
-     */
     float
-    getObjectHitRate() const;
+    getObjectHitRate() const override;
 
-    /**
-     * @return A number representing the success rate of hitting a successor in the cache versus missing it.
-     */
     float
-    getSuccessorHitRate() const;
+    getSuccessorHitRate() const override;
 
-    /**
-     * @brief Waits until the cache contains a specific sequence.
-     *
-     * @param seq The sequence to wait for
-     */
     void
-    waitUntilCacheContainsSeq(uint32_t seq);
+    waitUntilCacheContainsSeq(uint32_t seq) override;
 };
 
 }  // namespace data

src/data/LedgerCacheInterface.hpp

@@ -0,0 +1,173 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/Types.hpp"
+#include "etlng/Models.hpp"
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/hardened_hash.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace data {
+
+/**
+ * @brief Cache for an entire ledger.
+ */
+class LedgerCacheInterface {
+public:
+    virtual ~LedgerCacheInterface() = default;
+    LedgerCacheInterface() = default;
+    LedgerCacheInterface(LedgerCacheInterface&&) = delete;
+    LedgerCacheInterface(LedgerCacheInterface const&) = delete;
+    LedgerCacheInterface&
+    operator=(LedgerCacheInterface&&) = delete;
+    LedgerCacheInterface&
+    operator=(LedgerCacheInterface const&) = delete;
+
+    /**
+     * @brief Update the cache with new ledger objects.
+     *
+     * @param objs The ledger objects to update cache with
+     * @param seq The sequence to update cache for
+     * @param isBackground Should be set to true when writing old data from a background thread
+     */
+    virtual void
+    update(std::vector<LedgerObject> const& objs, uint32_t seq, bool isBackground = false) = 0;
+
+    /**
+     * @brief Update the cache with new ledger objects.
+     *
+     * @param objs The ledger objects to update cache with
+     * @param seq The sequence to update cache for
+     */
+    virtual void
+    update(std::vector<etlng::model::Object> const& objs, uint32_t seq) = 0;
+
+    /**
+     * @brief Fetch a cached object by its key and sequence number.
+     *
+     * @param key The key to fetch for
+     * @param seq The sequence to fetch for
+     * @return If found in cache, will return the cached Blob; otherwise nullopt is returned
+     */
+    virtual std::optional<Blob>
+    get(ripple::uint256 const& key, uint32_t seq) const = 0;
+
+    /**
+     * @brief Fetch a recently deleted object by its key and sequence number.
+     *
+     * @param key The key to fetch for
+     * @param seq The sequence to fetch for
+     * @return If found in deleted cache, will return the cached Blob; otherwise nullopt is returned
+     */
+    virtual std::optional<Blob>
+    getDeleted(ripple::uint256 const& key, uint32_t seq) const = 0;
+
+    /**
+     * @brief Gets a cached successor.
+     *
+     * Note: This function always returns std::nullopt when @ref isFull() returns false.
+     *
+     * @param key The key to fetch for
+     * @param seq The sequence to fetch for
+     * @return If found in cache, will return the cached successor; otherwise nullopt is returned
+     */
+    virtual std::optional<LedgerObject>
+    getSuccessor(ripple::uint256 const& key, uint32_t seq) const = 0;
+
+    /**
+     * @brief Gets a cached predcessor.
+     *
+     * Note: This function always returns std::nullopt when @ref isFull() returns false.
+     *
+     * @param key The key to fetch for
+     * @param seq The sequence to fetch for
+     * @return If found in cache, will return the cached predcessor; otherwise nullopt is returned
+     */
+    virtual std::optional<LedgerObject>
+    getPredecessor(ripple::uint256 const& key, uint32_t seq) const = 0;
+
+    /**
+     * @brief Disables the cache.
+     */
+    virtual void
+    setDisabled() = 0;
+
+    /**
+     * @return true if the cache is disabled; false otherwise
+     */
+    virtual bool
+    isDisabled() const = 0;
+
+    /**
+     * @brief Sets the full flag to true.
+     *
+     * This is used when cache loaded in its entirety at startup of the application. This can be either loaded from DB,
+     * populated together with initial ledger download (on first run) or downloaded from a peer node (specified in
+     * config).
+     */
+    virtual void
+    setFull() = 0;
+
+    /**
+     * @return The latest ledger sequence for which cache is available.
+     */
+    virtual uint32_t
+    latestLedgerSequence() const = 0;
+
+    /**
+     * @return true if the cache has all data for the most recent ledger; false otherwise
+     */
+    virtual bool
+    isFull() const = 0;
+
+    /**
+     * @return The total size of the cache.
+     */
+    virtual size_t
+    size() const = 0;
+
+    /**
+     * @return A number representing the success rate of hitting an object in the cache versus missing it.
+     */
+    virtual float
+    getObjectHitRate() const = 0;
+
+    /**
+     * @return A number representing the success rate of hitting a successor in the cache versus missing it.
+     */
+    virtual float
+    getSuccessorHitRate() const = 0;
+
+    /**
+     * @brief Waits until the cache contains a specific sequence.
+     *
+     * @param seq The sequence to wait for
+     */
+    virtual void
+    waitUntilCacheContainsSeq(uint32_t seq) = 0;
+};
+
+}  // namespace data

src/etl/CacheLoader.hpp

@@ -20,6 +20,7 @@
 #pragma once
 
 #include "data/BackendInterface.hpp"
+#include "data/LedgerCacheInterface.hpp"
 #include "etl/CacheLoaderSettings.hpp"
 #include "etl/impl/CacheLoader.hpp"
 #include "etl/impl/CursorFromAccountProvider.hpp"
@@ -44,13 +45,13 @@ namespace etl {
  * @tparam CursorProviderType The type of the cursor provider to use
  * @tparam ExecutionContextType The type of the execution context to use
  */
-template <typename CacheType, typename ExecutionContextType = util::async::CoroExecutionContext>
+template <typename ExecutionContextType = util::async::CoroExecutionContext>
 class CacheLoader {
-    using CacheLoaderType = impl::CacheLoaderImpl<CacheType>;
+    using CacheLoaderType = impl::CacheLoaderImpl<data::LedgerCacheInterface>;
 
     util::Logger log_{"ETL"};
     std::shared_ptr<BackendInterface> backend_;
-    std::reference_wrapper<CacheType> cache_;
+    std::reference_wrapper<data::LedgerCacheInterface> cache_;
 
     CacheLoaderSettings settings_;
     ExecutionContextType ctx_;
@@ -67,7 +68,7 @@ public:
     CacheLoader(
         util::config::ClioConfigDefinition const& config,
         std::shared_ptr<BackendInterface> const& backend,
-        CacheType& cache
+        data::LedgerCacheInterface& cache
     )
         : backend_{backend}, cache_{cache}, settings_{makeCacheLoaderSettings(config)}, ctx_{settings_.numThreads}
     {

src/etl/CorruptionDetector.hpp

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include "data/LedgerCacheInterface.hpp"
 #include "etl/SystemState.hpp"
 #include "util/log/Logger.hpp"
 
@@ -31,10 +32,9 @@ namespace etl {
  *
  * @tparam CacheType The type of the cache to disable on corruption
  */
-template <typename CacheType>
 class CorruptionDetector {
     std::reference_wrapper<SystemState> state_;
-    std::reference_wrapper<CacheType> cache_;
+    std::reference_wrapper<data::LedgerCacheInterface> cache_;
 
     util::Logger log_{"ETL"};
 
@@ -45,7 +45,8 @@ public:
      * @param state The system state
      * @param cache The cache to disable on corruption
      */
-    CorruptionDetector(SystemState& state, CacheType& cache) : state_{std::ref(state)}, cache_{std::ref(cache)}
+    CorruptionDetector(SystemState& state, data::LedgerCacheInterface& cache)
+        : state_{std::ref(state)}, cache_{std::ref(cache)}
     {
     }
 

src/etl/ETLService.cpp

@@ -20,9 +20,9 @@
 #include "etl/ETLService.hpp"
 
 #include "data/BackendInterface.hpp"
-#include "data/LedgerCache.hpp"
 #include "etl/CorruptionDetector.hpp"
 #include "etl/NetworkValidatedLedgersInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
 #include "util/Assert.hpp"
 #include "util/Constants.hpp"
@@ -44,6 +44,7 @@
 #include <vector>
 
 namespace etl {
+
 // Database must be populated when this starts
 std::optional<uint32_t>
 ETLService::runETLPipeline(uint32_t startSequence, uint32_t numExtractors)
@@ -266,7 +267,7 @@ ETLService::ETLService(
     boost::asio::io_context& ioc,
     std::shared_ptr<BackendInterface> backend,
     std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
-    std::shared_ptr<LoadBalancerType> balancer,
+    std::shared_ptr<etlng::LoadBalancerInterface> balancer,
     std::shared_ptr<NetworkValidatedLedgersInterface> ledgers
 )
     : backend_(backend)
@@ -285,6 +286,6 @@ ETLService::ETLService(
     txnThreshold_ = config.get<std::size_t>("txn_threshold");
 
     // This should probably be done in the backend factory but we don't have state available until here
-    backend_->setCorruptionDetector(CorruptionDetector<data::LedgerCache>{state_, backend->cache()});
+    backend_->setCorruptionDetector(CorruptionDetector{state_, backend->cache()});
 }
 }  // namespace etl

src/etl/ETLService.hpp

@@ -20,7 +20,6 @@
 #pragma once
 
 #include "data/BackendInterface.hpp"
-#include "data/LedgerCache.hpp"
 #include "etl/CacheLoader.hpp"
 #include "etl/ETLState.hpp"
 #include "etl/LoadBalancer.hpp"
@@ -33,7 +32,12 @@
 #include "etl/impl/LedgerLoader.hpp"
 #include "etl/impl/LedgerPublisher.hpp"
 #include "etl/impl/Transformer.hpp"
+#include "etlng/ETLService.hpp"
+#include "etlng/ETLServiceInterface.hpp"
+#include "etlng/LoadBalancer.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
+#include "util/Assert.hpp"
 #include "util/log/Logger.hpp"
 
 #include <boost/asio/io_context.hpp>
@@ -42,7 +46,6 @@
 #include <org/xrpl/rpc/v1/get_ledger.pb.h>
 #include <xrpl/proto/org/xrpl/rpc/v1/xrp_ledger.grpc.pb.h>
 
-#include <concepts>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
@@ -82,16 +85,14 @@ concept SomeETLService = std::derived_from<T, ETLServiceTag>;
  * the others will fall back to monitoring/publishing. In this sense, this class dynamically transitions from monitoring
  * to writing and from writing to monitoring, based on the activity of other processes running on different machines.
  */
-class ETLService : public ETLServiceTag {
+class ETLService : public etlng::ETLServiceInterface, ETLServiceTag {
     // TODO: make these template parameters in ETLService
-    using LoadBalancerType = LoadBalancer;
     using DataPipeType = etl::impl::ExtractionDataPipe<org::xrpl::rpc::v1::GetLedgerResponse>;
-    using CacheType = data::LedgerCache;
-    using CacheLoaderType = etl::CacheLoader<CacheType>;
-    using LedgerFetcherType = etl::impl::LedgerFetcher<LoadBalancerType>;
+    using CacheLoaderType = etl::CacheLoader<>;
+    using LedgerFetcherType = etl::impl::LedgerFetcher;
     using ExtractorType = etl::impl::Extractor<DataPipeType, LedgerFetcherType>;
-    using LedgerLoaderType = etl::impl::LedgerLoader<LoadBalancerType, LedgerFetcherType>;
-    using LedgerPublisherType = etl::impl::LedgerPublisher<CacheType>;
+    using LedgerLoaderType = etl::impl::LedgerLoader<LedgerFetcherType>;
+    using LedgerPublisherType = etl::impl::LedgerPublisher;
     using AmendmentBlockHandlerType = etl::impl::AmendmentBlockHandler;
     using TransformerType =
         etl::impl::Transformer<DataPipeType, LedgerLoaderType, LedgerPublisherType, AmendmentBlockHandlerType>;
@@ -99,7 +100,7 @@ class ETLService : public ETLServiceTag {
     util::Logger log_{"ETL"};
 
     std::shared_ptr<BackendInterface> backend_;
-    std::shared_ptr<LoadBalancerType> loadBalancer_;
+    std::shared_ptr<etlng::LoadBalancerInterface> loadBalancer_;
     std::shared_ptr<NetworkValidatedLedgersInterface> networkValidatedLedgers_;
 
     std::uint32_t extractorThreads_ = 1;
@@ -134,10 +135,15 @@ public:
         boost::asio::io_context& ioc,
         std::shared_ptr<BackendInterface> backend,
         std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
-        std::shared_ptr<LoadBalancerType> balancer,
+        std::shared_ptr<etlng::LoadBalancerInterface> balancer,
         std::shared_ptr<NetworkValidatedLedgersInterface> ledgers
     );
 
+    /**
+     * @brief Move constructor is deleted because ETL service shares its fields by reference
+     */
+    ETLService(ETLService&&) = delete;
+
     /**
      * @brief A factory function to spawn new ETLService instances.
      *
@@ -151,20 +157,33 @@ public:
      * @param ledgers The network validated ledgers datastructure
      * @return A shared pointer to a new instance of ETLService
      */
-    static std::shared_ptr<ETLService>
+    static std::shared_ptr<etlng::ETLServiceInterface>
     makeETLService(
         util::config::ClioConfigDefinition const& config,
         boost::asio::io_context& ioc,
         std::shared_ptr<BackendInterface> backend,
         std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
-        std::shared_ptr<LoadBalancerType> balancer,
+        std::shared_ptr<etlng::LoadBalancerInterface> balancer,
         std::shared_ptr<NetworkValidatedLedgersInterface> ledgers
     )
     {
-        auto etl = std::make_shared<ETLService>(config, ioc, backend, subscriptions, balancer, ledgers);
-        etl->run();
+        std::shared_ptr<etlng::ETLServiceInterface> ret;
 
-        return etl;
+        if (config.get<bool>("__ng_etl")) {
+            ASSERT(
+                std::dynamic_pointer_cast<etlng::LoadBalancer>(balancer),
+                "LoadBalancer type must be etlng::LoadBalancer"
+            );
+            ret = std::make_shared<etlng::ETLService>(config, backend, subscriptions, balancer, ledgers);
+        } else {
+            ASSERT(
+                std::dynamic_pointer_cast<etl::LoadBalancer>(balancer), "LoadBalancer type must be etl::LoadBalancer"
+            );
+            ret = std::make_shared<etl::ETLService>(config, ioc, backend, subscriptions, balancer, ledgers);
+        }
+
+        ret->run();
+        return ret;
     }
 
     /**
@@ -181,7 +200,7 @@ public:
      * @note This method blocks until the ETL service has stopped.
      */
     void
-    stop()
+    stop() override
     {
         LOG(log_.info()) << "Stop called";
 
@@ -200,7 +219,7 @@ public:
      * @return Time passed since last ledger close
      */
     std::uint32_t
-    lastCloseAgeSeconds() const
+    lastCloseAgeSeconds() const override
     {
         return ledgerPublisher_.lastCloseAgeSeconds();
     }
@@ -211,7 +230,7 @@ public:
      * @return true if currently amendment blocked; false otherwise
      */
     bool
-    isAmendmentBlocked() const
+    isAmendmentBlocked() const override
     {
         return state_.isAmendmentBlocked;
     }
@@ -222,7 +241,7 @@ public:
      * @return true if corruption of DB was detected and cache was stopped.
      */
     bool
-    isCorruptionDetected() const
+    isCorruptionDetected() const override
     {
         return state_.isCorruptionDetected;
     }
@@ -233,7 +252,7 @@ public:
      * @return The state of ETL as a JSON object
      */
     boost::json::object
-    getInfo() const
+    getInfo() const override
     {
         boost::json::object result;
 
@@ -251,11 +270,17 @@ public:
      * @return The etl nodes' state, nullopt if etl nodes are not connected
      */
     std::optional<etl::ETLState>
-    getETLState() const noexcept
+    getETLState() const noexcept override
     {
         return loadBalancer_->getETLState();
     }
 
+    /**
+     * @brief Start all components to run ETL service.
+     */
+    void
+    run() override;
+
 private:
     /**
      * @brief Run the ETL pipeline.
@@ -322,12 +347,6 @@ private:
         return numMarkers_;
     }
 
-    /**
-     * @brief Start all components to run ETL service.
-     */
-    void
-    run();
-
     /**
      * @brief Spawn the worker thread and start monitoring.
      */

src/etl/ETLState.cpp

@@ -31,15 +31,12 @@
 
 namespace etl {
 
-std::optional<ETLState>
-tag_invoke(boost::json::value_to_tag<std::optional<ETLState>>, boost::json::value const& jv)
+ETLState
+tag_invoke(boost::json::value_to_tag<ETLState>, boost::json::value const& jv)
 {
     ETLState state;
     auto const& jsonObject = jv.as_object();
 
-    if (jsonObject.contains(JS(error)))
-        return std::nullopt;
-
     if (jsonObject.contains(JS(result)) && jsonObject.at(JS(result)).as_object().contains(JS(info))) {
         auto const rippledInfo = jsonObject.at(JS(result)).as_object().at(JS(info)).as_object();
         if (rippledInfo.contains(JS(network_id)))

src/etl/ETLState.hpp

@@ -20,12 +20,14 @@
 #pragma once
 
 #include "data/BackendInterface.hpp"
+#include "rpc/JS.hpp"
 
 #include <boost/json.hpp>
 #include <boost/json/conversion.hpp>
 #include <boost/json/object.hpp>
 #include <boost/json/value.hpp>
 #include <boost/json/value_to.hpp>
+#include <xrpl/protocol/jss.h>
 
 #include <cstdint>
 #include <optional>
@@ -54,8 +56,9 @@ struct ETLState {
             return std::nullopt;
         });
 
-        if (serverInfoRippled)
-            return boost::json::value_to<std::optional<ETLState>>(boost::json::value(*serverInfoRippled));
+        if (serverInfoRippled && not serverInfoRippled->contains(JS(error))) {
+            return boost::json::value_to<ETLState>(boost::json::value(*serverInfoRippled));
+        }
 
         return std::nullopt;
     }
@@ -67,7 +70,7 @@ struct ETLState {
  * @param jv The json value to convert
  * @return The ETLState
  */
-std::optional<ETLState>
-tag_invoke(boost::json::value_to_tag<std::optional<ETLState>>, boost::json::value const& jv);
+ETLState
+tag_invoke(boost::json::value_to_tag<ETLState>, boost::json::value const& jv);
 
 }  // namespace etl

src/etl/LoadBalancer.cpp

@@ -23,16 +23,20 @@
 #include "etl/ETLState.hpp"
 #include "etl/NetworkValidatedLedgersInterface.hpp"
 #include "etl/Source.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
 #include "rpc/Errors.hpp"
 #include "util/Assert.hpp"
 #include "util/CoroutineGroup.hpp"
+#include "util/Profiler.hpp"
 #include "util/Random.hpp"
 #include "util/ResponseExpirationCache.hpp"
 #include "util/log/Logger.hpp"
 #include "util/newconfig/ArrayView.hpp"
 #include "util/newconfig/ConfigDefinition.hpp"
 #include "util/newconfig/ObjectView.hpp"
+#include "util/prometheus/Label.hpp"
+#include "util/prometheus/Prometheus.hpp"
 
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/spawn.hpp>
@@ -56,10 +60,11 @@
 #include <vector>
 
 using namespace util::config;
+using util::prometheus::Labels;
 
 namespace etl {
 
-std::shared_ptr<LoadBalancer>
+std::shared_ptr<etlng::LoadBalancerInterface>
 LoadBalancer::makeLoadBalancer(
     ClioConfigDefinition const& config,
     boost::asio::io_context& ioc,
@@ -82,6 +87,34 @@ LoadBalancer::LoadBalancer(
     std::shared_ptr<NetworkValidatedLedgersInterface> validatedLedgers,
     SourceFactory sourceFactory
 )
+    : forwardingCounters_{
+          .successDuration = PrometheusService::counterInt(
+              "forwarding_duration_milliseconds_counter",
+              Labels({util::prometheus::Label{"status", "success"}}),
+              "The duration of processing successful forwarded requests"
+          ),
+          .failDuration = PrometheusService::counterInt(
+              "forwarding_duration_milliseconds_counter",
+              Labels({util::prometheus::Label{"status", "fail"}}),
+              "The duration of processing failed forwarded requests"
+          ),
+          .retries = PrometheusService::counterInt(
+              "forwarding_retries_counter",
+              Labels(),
+              "The number of retries before a forwarded request was successful. Initial attempt excluded"
+          ),
+          .cacheHit = PrometheusService::counterInt(
+              "forwarding_cache_hit_counter",
+              Labels(),
+              "The number of requests that we served from the cache"
+          ),
+          .cacheMiss = PrometheusService::counterInt(
+              "forwarding_cache_miss_counter",
+              Labels(),
+              "The number of requests that were not served from the cache"
+          )
+      }
+
 {
     auto const forwardingCacheTimeout = config.get<float>("forwarding.cache_timeout");
     if (forwardingCacheTimeout > 0.f) {
@@ -175,12 +208,12 @@ LoadBalancer::~LoadBalancer()
 }
 
 std::vector<std::string>
-LoadBalancer::loadInitialLedger(uint32_t sequence, bool cacheOnly, std::chrono::steady_clock::duration retryAfter)
+LoadBalancer::loadInitialLedger(uint32_t sequence, std::chrono::steady_clock::duration retryAfter)
 {
     std::vector<std::string> response;
     execute(
-        [this, &response, &sequence, cacheOnly](auto& source) {
-            auto [data, res] = source->loadInitialLedger(sequence, downloadRanges_, cacheOnly);
+        [this, &response, &sequence](auto& source) {
+            auto [data, res] = source->loadInitialLedger(sequence, downloadRanges_);
 
             if (!res) {
                 LOG(log_.error()) << "Failed to download initial ledger."
@@ -241,9 +274,11 @@ LoadBalancer::forwardToRippled(
     auto const cmd = boost::json::value_to<std::string>(request.at("command"));
     if (forwardingCache_) {
         if (auto cachedResponse = forwardingCache_->get(cmd); cachedResponse) {
+            ++forwardingCounters_.cacheHit.get();
             return std::move(cachedResponse).value();
         }
     }
+    ++forwardingCounters_.cacheMiss.get();
 
     ASSERT(not sources_.empty(), "ETL sources must be configured to forward requests.");
     std::size_t sourceIdx = util::Random::uniform(0ul, sources_.size() - 1);
@@ -255,11 +290,15 @@ LoadBalancer::forwardToRippled(
     std::optional<boost::json::object> response;
     rpc::ClioError error = rpc::ClioError::EtlConnectionError;
     while (numAttempts < sources_.size()) {
-        auto res = sources_[sourceIdx]->forwardToRippled(request, clientIp, xUserValue, yield);
+        auto [res, duration] =
+            util::timed([&]() { return sources_[sourceIdx]->forwardToRippled(request, clientIp, xUserValue, yield); });
         if (res) {
+            forwardingCounters_.successDuration.get() += duration;
             response = std::move(res).value();
             break;
         }
+        forwardingCounters_.failDuration.get() += duration;
+        ++forwardingCounters_.retries.get();
         error = std::max(error, res.error());  // Choose the best result between all sources
 
         sourceIdx = (sourceIdx + 1) % sources_.size();

src/etl/LoadBalancer.hpp

@@ -23,12 +23,16 @@
 #include "etl/ETLState.hpp"
 #include "etl/NetworkValidatedLedgersInterface.hpp"
 #include "etl/Source.hpp"
+#include "etlng/InitialLoadObserverInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
 #include "rpc/Errors.hpp"
+#include "util/Assert.hpp"
 #include "util/Mutex.hpp"
 #include "util/ResponseExpirationCache.hpp"
 #include "util/log/Logger.hpp"
 #include "util/newconfig/ConfigDefinition.hpp"
+#include "util/prometheus/Counter.hpp"
 
 #include <boost/asio.hpp>
 #include <boost/asio/io_context.hpp>
@@ -44,10 +48,12 @@
 #include <concepts>
 #include <cstdint>
 #include <expected>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
 #include <string_view>
+#include <utility>
 #include <vector>
 
 namespace etl {
@@ -69,7 +75,7 @@ concept SomeLoadBalancer = std::derived_from<T, LoadBalancerTag>;
  * which ledgers have been validated by the network, and the range of ledgers each etl source has). This class also
  * allows requests for ledger data to be load balanced across all possible ETL sources.
  */
-class LoadBalancer : public LoadBalancerTag {
+class LoadBalancer : public etlng::LoadBalancerInterface, LoadBalancerTag {
 public:
     using RawLedgerObjectType = org::xrpl::rpc::v1::RawLedgerObject;
     using GetLedgerResponseType = org::xrpl::rpc::v1::GetLedgerResponse;
@@ -88,6 +94,14 @@ private:
     std::uint32_t downloadRanges_ =
         kDEFAULT_DOWNLOAD_RANGES; /*< The number of markers to use when downloading initial ledger */
 
+    struct ForwardingCounters {
+        std::reference_wrapper<util::prometheus::CounterInt> successDuration;
+        std::reference_wrapper<util::prometheus::CounterInt> failDuration;
+        std::reference_wrapper<util::prometheus::CounterInt> retries;
+        std::reference_wrapper<util::prometheus::CounterInt> cacheHit;
+        std::reference_wrapper<util::prometheus::CounterInt> cacheMiss;
+    } forwardingCounters_;
+
     // Using mutext instead of atomic_bool because choosing a new source to
     // forward messages should be done with a mutual exclusion otherwise there will be a race condition
     util::Mutex<bool> hasForwardingSource_{false};
@@ -133,7 +147,7 @@ public:
      * @param sourceFactory A factory function to create a source
      * @return A shared pointer to a new instance of LoadBalancer
      */
-    static std::shared_ptr<LoadBalancer>
+    static std::shared_ptr<LoadBalancerInterface>
     makeLoadBalancer(
         util::config::ClioConfigDefinition const& config,
         boost::asio::io_context& ioc,
@@ -150,16 +164,32 @@ public:
      * @note This function will retry indefinitely until the ledger is downloaded.
      *
      * @param sequence Sequence of ledger to download
-     * @param cacheOnly Whether to only write to cache and not to the DB; defaults to false
+     * @param retryAfter Time to wait between retries (2 seconds by default)
+     * @return A std::vector<std::string> The ledger data
+     */
+    std::vector<std::string>
+    loadInitialLedger(uint32_t sequence, std::chrono::steady_clock::duration retryAfter = std::chrono::seconds{2})
+        override;
+
+    /**
+     * @brief Load the initial ledger, writing data to the queue.
+     * @note This function will retry indefinitely until the ledger is downloaded.
+     *
+     * @param sequence Sequence of ledger to download
+     * @param observer The observer to notify of progress
      * @param retryAfter Time to wait between retries (2 seconds by default)
      * @return A std::vector<std::string> The ledger data
      */
     std::vector<std::string>
     loadInitialLedger(
-        uint32_t sequence,
-        bool cacheOnly = false,
-        std::chrono::steady_clock::duration retryAfter = std::chrono::seconds{2}
-    );
+        [[maybe_unused]] uint32_t sequence,
+        [[maybe_unused]] etlng::InitialLoadObserverInterface& observer,
+        [[maybe_unused]] std::chrono::steady_clock::duration retryAfter
+    ) override
+    {
+        ASSERT(false, "Not available for old ETL");
+        std::unreachable();
+    }
 
     /**
      * @brief Fetch data for a specific ledger.
@@ -180,7 +210,7 @@ public:
         bool getObjects,
         bool getObjectNeighbors,
         std::chrono::steady_clock::duration retryAfter = std::chrono::seconds{2}
-    );
+    ) override;
 
     /**
      * @brief Represent the state of this load balancer as a JSON object
@@ -188,7 +218,7 @@ public:
      * @return JSON representation of the state of this load balancer.
      */
     boost::json::value
-    toJson() const;
+    toJson() const override;
 
     /**
      * @brief Forward a JSON RPC request to a randomly selected rippled node.
@@ -205,14 +235,14 @@ public:
         std::optional<std::string> const& clientIp,
         bool isAdmin,
         boost::asio::yield_context yield
-    );
+    ) override;
 
     /**
      * @brief Return state of ETL nodes.
      * @return ETL state, nullopt if etl nodes not available
      */
     std::optional<ETLState>
-    getETLState() noexcept;
+    getETLState() noexcept override;
 
     /**
      * @brief Stop the load balancer. This will stop all subscription sources.
@@ -221,7 +251,7 @@ public:
      * @param yield The coroutine context
      */
     void
-    stop(boost::asio::yield_context yield);
+    stop(boost::asio::yield_context yield) override;
 
 private:
     /**

src/etl/NetworkValidatedLedgers.cpp

@@ -19,6 +19,8 @@
 
 #include "etl/NetworkValidatedLedgers.hpp"
 
+#include <boost/signals2/connection.hpp>
+
 #include <chrono>
 #include <cstdint>
 #include <memory>
@@ -35,25 +37,27 @@ NetworkValidatedLedgers::makeValidatedLedgers()
 void
 NetworkValidatedLedgers::push(uint32_t idx)
 {
-    std::lock_guard const lck(m_);
-    if (!max_ || idx > *max_)
-        max_ = idx;
+    std::lock_guard const lck(mtx_);
+    if (!latest_ || idx > *latest_)
+        latest_ = idx;
+
+    notificationChannel_(idx);
     cv_.notify_all();
 }
 
 std::optional<uint32_t>
 NetworkValidatedLedgers::getMostRecent()
 {
-    std::unique_lock lck(m_);
-    cv_.wait(lck, [this]() { return max_; });
-    return max_;
+    std::unique_lock lck(mtx_);
+    cv_.wait(lck, [this]() { return latest_; });
+    return latest_;
 }
 
 bool
 NetworkValidatedLedgers::waitUntilValidatedByNetwork(uint32_t sequence, std::optional<uint32_t> maxWaitMs)
 {
-    std::unique_lock lck(m_);
-    auto pred = [sequence, this]() -> bool { return (max_ && sequence <= *max_); };
+    std::unique_lock lck(mtx_);
+    auto pred = [sequence, this]() -> bool { return (latest_ && sequence <= *latest_); };
     if (maxWaitMs) {
         cv_.wait_for(lck, std::chrono::milliseconds(*maxWaitMs));
     } else {
@@ -62,4 +66,10 @@ NetworkValidatedLedgers::waitUntilValidatedByNetwork(uint32_t sequence, std::opt
     return pred();
 }
 
+boost::signals2::scoped_connection
+NetworkValidatedLedgers::subscribe(SignalType::slot_type const& subscriber)
+{
+    return notificationChannel_.connect(subscriber);
+}
+
 }  // namespace etl

src/etl/NetworkValidatedLedgers.hpp

@@ -21,6 +21,10 @@
 
 #include "etl/NetworkValidatedLedgersInterface.hpp"
 
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/signal.hpp>
+#include <boost/signals2/variadic_signal.hpp>
+
 #include <condition_variable>
 #include <cstdint>
 #include <memory>
@@ -38,12 +42,13 @@ namespace etl {
  * remains stopped for the rest of its lifetime.
  */
 class NetworkValidatedLedgers : public NetworkValidatedLedgersInterface {
-    // max sequence validated by network
-    std::optional<uint32_t> max_;
+    std::optional<uint32_t> latest_;  // currently known latest sequence validated by network
 
-    mutable std::mutex m_;
+    mutable std::mutex mtx_;
     std::condition_variable cv_;
 
+    SignalType notificationChannel_;
+
 public:
     /**
      * @brief A factory function for NetworkValidatedLedgers
@@ -81,6 +86,9 @@ public:
      */
     bool
     waitUntilValidatedByNetwork(uint32_t sequence, std::optional<uint32_t> maxWaitMs = {}) final;
+
+    boost::signals2::scoped_connection
+    subscribe(SignalType::slot_type const& subscriber) override;
 };
 
 }  // namespace etl

src/etl/NetworkValidatedLedgersInterface.hpp

@@ -20,8 +20,13 @@
 /** @file */
 #pragma once
 
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/signal.hpp>
+#include <boost/signals2/variadic_signal.hpp>
+
 #include <cstdint>
 #include <optional>
+
 namespace etl {
 
 /**
@@ -29,6 +34,8 @@ namespace etl {
  */
 class NetworkValidatedLedgersInterface {
 public:
+    using SignalType = boost::signals2::signal<void(uint32_t)>;
+
     virtual ~NetworkValidatedLedgersInterface() = default;
 
     /**
@@ -46,7 +53,7 @@ public:
      *
      * @return Sequence of most recently validated ledger. empty optional if the datastructure has been stopped
      */
-    virtual std::optional<uint32_t>
+    [[nodiscard]] virtual std::optional<uint32_t>
     getMostRecent() = 0;
 
     /**
@@ -59,6 +66,15 @@ public:
      */
     virtual bool
     waitUntilValidatedByNetwork(uint32_t sequence, std::optional<uint32_t> maxWaitMs = {}) = 0;
+
+    /**
+     * @brief Allows clients to get notified when a new validated ledger becomes known to Clio
+     *
+     * @param subscriber The slot to connect
+     * @return A connection object that automatically disconnects the subscription once destroyed
+     */
+    [[nodiscard]] virtual boost::signals2::scoped_connection
+    subscribe(SignalType::slot_type const& subscriber) = 0;
 };
 
 }  // namespace etl

src/etl/Source.hpp

@@ -23,8 +23,6 @@
 #include "etl/NetworkValidatedLedgersInterface.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
 #include "rpc/Errors.hpp"
-#include "util/log/Logger.hpp"
-#include "util/newconfig/ConfigDefinition.hpp"
 #include "util/newconfig/ObjectView.hpp"
 
 #include <boost/asio/io_context.hpp>
@@ -130,11 +128,10 @@ public:
      *
      * @param sequence Sequence of the ledger to download
      * @param numMarkers Number of markers to generate for async calls
-     * @param cacheOnly Only insert into cache, not the DB; defaults to false
      * @return A std::pair of the data and a bool indicating whether the download was successful
      */
     virtual std::pair<std::vector<std::string>, bool>
-    loadInitialLedger(uint32_t sequence, std::uint32_t numMarkers, bool cacheOnly = false) = 0;
+    loadInitialLedger(uint32_t sequence, std::uint32_t numMarkers) = 0;
 
     /**
      * @brief Forward a request to rippled.

src/etl/impl/GrpcSource.cpp

@@ -98,7 +98,7 @@ GrpcSource::fetchLedger(uint32_t sequence, bool getObjects, bool getObjectNeighb
 }
 
 std::pair<std::vector<std::string>, bool>
-GrpcSource::loadInitialLedger(uint32_t const sequence, uint32_t const numMarkers, bool const cacheOnly)
+GrpcSource::loadInitialLedger(uint32_t const sequence, uint32_t const numMarkers)
 {
     if (!stub_)
         return {{}, false};
@@ -130,7 +130,7 @@ GrpcSource::loadInitialLedger(uint32_t const sequence, uint32_t const numMarkers
 
         LOG(log_.trace()) << "Marker prefix = " << ptr->getMarkerPrefix();
 
-        auto result = ptr->process(stub_, cq, *backend_, abort, cacheOnly);
+        auto result = ptr->process(stub_, cq, *backend_, abort);
         if (result != etl::impl::AsyncCallData::CallStatus::MORE) {
             ++numFinished;
             LOG(log_.debug()) << "Finished a marker. Current number of finished = " << numFinished;

src/etl/impl/GrpcSource.hpp

@@ -60,11 +60,10 @@ public:
      *
      * @param sequence Sequence of the ledger to download
      * @param numMarkers Number of markers to generate for async calls
-     * @param cacheOnly Only insert into cache, not the DB; defaults to false
      * @return A std::pair of the data and a bool indicating whether the download was successful
      */
     std::pair<std::vector<std::string>, bool>
-    loadInitialLedger(uint32_t sequence, uint32_t numMarkers, bool cacheOnly = false);
+    loadInitialLedger(uint32_t sequence, uint32_t numMarkers);
 };
 
 }  // namespace etl::impl

src/etl/impl/LedgerFetcher.hpp

@@ -20,6 +20,8 @@
 #pragma once
 
 #include "data/BackendInterface.hpp"
+#include "etl/LedgerFetcherInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "util/log/Logger.hpp"
 
 #include <grpcpp/grpcpp.h>
@@ -34,22 +36,18 @@ namespace etl::impl {
 /**
  * @brief GRPC Ledger data fetcher
  */
-template <typename LoadBalancerType>
-class LedgerFetcher {
-public:
-    using OptionalGetLedgerResponseType = typename LoadBalancerType::OptionalGetLedgerResponseType;
-
+class LedgerFetcher : public LedgerFetcherInterface {
 private:
     util::Logger log_{"ETL"};
 
     std::shared_ptr<BackendInterface> backend_;
-    std::shared_ptr<LoadBalancerType> loadBalancer_;
+    std::shared_ptr<etlng::LoadBalancerInterface> loadBalancer_;
 
 public:
     /**
      * @brief Create an instance of the fetcher
      */
-    LedgerFetcher(std::shared_ptr<BackendInterface> backend, std::shared_ptr<LoadBalancerType> balancer)
+    LedgerFetcher(std::shared_ptr<BackendInterface> backend, std::shared_ptr<etlng::LoadBalancerInterface> balancer)
         : backend_(std::move(backend)), loadBalancer_(std::move(balancer))
     {
     }
@@ -64,7 +62,7 @@ public:
      * @return Ledger header and transaction+metadata blobs; Empty optional if the server is shutting down
      */
     [[nodiscard]] OptionalGetLedgerResponseType
-    fetchData(uint32_t sequence)
+    fetchData(uint32_t sequence) override
     {
         LOG(log_.debug()) << "Attempting to fetch ledger with sequence = " << sequence;
 
@@ -84,7 +82,7 @@ public:
      * @return Ledger data diff between sequance and parent; Empty optional if the server is shutting down
      */
     [[nodiscard]] OptionalGetLedgerResponseType
-    fetchDataAndDiff(uint32_t sequence)
+    fetchDataAndDiff(uint32_t sequence) override
     {
         LOG(log_.debug()) << "Attempting to fetch ledger with sequence = " << sequence;
 

src/etl/impl/LedgerLoader.hpp

@@ -26,6 +26,7 @@
 #include "etl/NFTHelpers.hpp"
 #include "etl/SystemState.hpp"
 #include "etl/impl/LedgerFetcher.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "util/Assert.hpp"
 #include "util/LedgerUtils.hpp"
 #include "util/Profiler.hpp"
@@ -65,18 +66,18 @@ namespace etl::impl {
 /**
  * @brief Loads ledger data into the DB
  */
-template <typename LoadBalancerType, typename LedgerFetcherType>
+template <typename LedgerFetcherType>
 class LedgerLoader {
 public:
-    using GetLedgerResponseType = typename LoadBalancerType::GetLedgerResponseType;
-    using OptionalGetLedgerResponseType = typename LoadBalancerType::OptionalGetLedgerResponseType;
-    using RawLedgerObjectType = typename LoadBalancerType::RawLedgerObjectType;
+    using GetLedgerResponseType = etlng::LoadBalancerInterface::GetLedgerResponseType;
+    using OptionalGetLedgerResponseType = etlng::LoadBalancerInterface::OptionalGetLedgerResponseType;
+    using RawLedgerObjectType = etlng::LoadBalancerInterface::RawLedgerObjectType;
 
 private:
     util::Logger log_{"ETL"};
 
     std::shared_ptr<BackendInterface> backend_;
-    std::shared_ptr<LoadBalancerType> loadBalancer_;
+    std::shared_ptr<etlng::LoadBalancerInterface> loadBalancer_;
     std::reference_wrapper<LedgerFetcherType> fetcher_;
     std::reference_wrapper<SystemState const> state_;  // shared state for ETL
 
@@ -86,7 +87,7 @@ public:
      */
     LedgerLoader(
         std::shared_ptr<BackendInterface> backend,
-        std::shared_ptr<LoadBalancerType> balancer,
+        std::shared_ptr<etlng::LoadBalancerInterface> balancer,
         LedgerFetcherType& fetcher,
         SystemState const& state
     )
@@ -121,7 +122,7 @@ public:
 
             LOG(log_.trace()) << "Inserting transaction = " << sttx.getTransactionID();
 
-            ripple::TxMeta txMeta{sttx.getTransactionID(), ledger.seq, txn.metadata_blob()};
+            ripple::TxMeta const txMeta{sttx.getTransactionID(), ledger.seq, txn.metadata_blob()};
 
             auto const [nftTxs, maybeNFT] = getNFTDataFromTx(txMeta, sttx);
             result.nfTokenTxData.insert(result.nfTokenTxData.end(), nftTxs.begin(), nftTxs.end());

src/etl/impl/LedgerPublisher.hpp

@@ -21,6 +21,7 @@
 
 #include "data/BackendInterface.hpp"
 #include "data/DBHelpers.hpp"
+#include "data/LedgerCacheInterface.hpp"
 #include "data/Types.hpp"
 #include "etl/SystemState.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
@@ -38,6 +39,7 @@
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/Serializer.h>
 
+#include <algorithm>
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
@@ -64,14 +66,13 @@ namespace etl::impl {
  * includes reading all of the transactions from the database) is done from the application wide asio io_service, and a
  * strand is used to ensure ledgers are published in order.
  */
-template <typename CacheType>
 class LedgerPublisher {
     util::Logger log_{"ETL"};
 
     boost::asio::strand<boost::asio::io_context::executor_type> publishStrand_;
 
     std::shared_ptr<BackendInterface> backend_;
-    std::reference_wrapper<CacheType> cache_;
+    std::reference_wrapper<data::LedgerCacheInterface> cache_;
     std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions_;
     std::reference_wrapper<SystemState const> state_;  // shared state for ETL
 
@@ -94,7 +95,7 @@ public:
     LedgerPublisher(
         boost::asio::io_context& ioc,
         std::shared_ptr<BackendInterface> backend,
-        CacheType& cache,
+        data::LedgerCacheInterface& cache,
         std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
         SystemState const& state
     )
@@ -205,7 +206,7 @@ public:
                 subscriptions_->pubLedger(lgrInfo, *fees, range, transactions.size());
 
                 // order with transaction index
-                std::sort(transactions.begin(), transactions.end(), [](auto const& t1, auto const& t2) {
+                std::ranges::sort(transactions, [](auto const& t1, auto const& t2) {
                     ripple::SerialIter iter1{t1.metadata.data(), t1.metadata.size()};
                     ripple::STObject const object1(iter1, ripple::sfMetadata);
                     ripple::SerialIter iter2{t2.metadata.data(), t2.metadata.size()};

src/etl/impl/SourceImpl.hpp

@@ -202,9 +202,9 @@ public:
      * @return A std::pair of the data and a bool indicating whether the download was successful
      */
     std::pair<std::vector<std::string>, bool>
-    loadInitialLedger(uint32_t sequence, std::uint32_t numMarkers, bool cacheOnly = false) final
+    loadInitialLedger(uint32_t sequence, std::uint32_t numMarkers) final
     {
-        return grpcSource_.loadInitialLedger(sequence, numMarkers, cacheOnly);
+        return grpcSource_.loadInitialLedger(sequence, numMarkers);
     }
 
     /**

src/etlng/CMakeLists.txt

@@ -1,8 +1,21 @@
 add_library(clio_etlng)
 
 target_sources(
-  clio_etlng PRIVATE impl/AmendmentBlockHandler.cpp impl/AsyncGrpcCall.cpp impl/Extraction.cpp impl/GrpcSource.cpp
-                     impl/Loading.cpp impl/TaskManager.cpp
+  clio_etlng
+  PRIVATE LoadBalancer.cpp
+          Source.cpp
+          impl/AmendmentBlockHandler.cpp
+          impl/AsyncGrpcCall.cpp
+          impl/Extraction.cpp
+          impl/GrpcSource.cpp
+          impl/ForwardingSource.cpp
+          impl/Loading.cpp
+          impl/Monitor.cpp
+          impl/TaskManager.cpp
+          impl/ext/Cache.cpp
+          impl/ext/Core.cpp
+          impl/ext/NFT.cpp
+          impl/ext/Successor.cpp
 )
 
 target_link_libraries(clio_etlng PUBLIC clio_data)

src/etlng/ETLService.hpp

@@ -0,0 +1,283 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "data/LedgerCache.hpp"
+#include "data/Types.hpp"
+#include "etl/CacheLoader.hpp"
+#include "etl/ETLState.hpp"
+#include "etl/LedgerFetcherInterface.hpp"
+#include "etl/NetworkValidatedLedgersInterface.hpp"
+#include "etl/SystemState.hpp"
+#include "etl/impl/AmendmentBlockHandler.hpp"
+#include "etl/impl/LedgerFetcher.hpp"
+#include "etl/impl/LedgerPublisher.hpp"
+#include "etlng/AmendmentBlockHandlerInterface.hpp"
+#include "etlng/ETLServiceInterface.hpp"
+#include "etlng/ExtractorInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
+#include "etlng/impl/AmendmentBlockHandler.hpp"
+#include "etlng/impl/Extraction.hpp"
+#include "etlng/impl/Loading.hpp"
+#include "etlng/impl/Monitor.hpp"
+#include "etlng/impl/Registry.hpp"
+#include "etlng/impl/Scheduling.hpp"
+#include "etlng/impl/TaskManager.hpp"
+#include "etlng/impl/ext/Cache.hpp"
+#include "etlng/impl/ext/Core.hpp"
+#include "etlng/impl/ext/NFT.hpp"
+#include "etlng/impl/ext/Successor.hpp"
+#include "feed/SubscriptionManagerInterface.hpp"
+#include "util/Assert.hpp"
+#include "util/Profiler.hpp"
+#include "util/async/context/BasicExecutionContext.hpp"
+#include "util/config/Config.hpp"
+#include "util/log/Logger.hpp"
+#include "util/newconfig/ConfigDefinition.hpp"
+
+#include <boost/json/object.hpp>
+#include <fmt/core.h>
+#include <xrpl/basics/Blob.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/strHex.h>
+#include <xrpl/proto/org/xrpl/rpc/v1/get_ledger.pb.h>
+#include <xrpl/proto/org/xrpl/rpc/v1/ledger.pb.h>
+#include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/protocol/TxMeta.h>
+
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <utility>
+
+namespace etlng {
+
+/**
+ * @brief This class is responsible for continuously extracting data from a p2p node, and writing that data to the
+ * databases.
+ *
+ * Usually, multiple different processes share access to the same network accessible databases, in which case only one
+ * such process is performing ETL and writing to the database. The other processes simply monitor the database for new
+ * ledgers, and publish those ledgers to the various subscription streams. If a monitoring process determines that the
+ * ETL writer has failed (no new ledgers written for some time), the process will attempt to become the ETL writer.
+ *
+ * If there are multiple monitoring processes that try to become the ETL writer at the same time, one will win out, and
+ * the others will fall back to monitoring/publishing. In this sense, this class dynamically transitions from monitoring
+ * to writing and from writing to monitoring, based on the activity of other processes running on different machines.
+ */
+class ETLService : public ETLServiceInterface {
+    util::Logger log_{"ETL"};
+
+    std::shared_ptr<BackendInterface> backend_;
+    std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions_;
+    std::shared_ptr<etlng::LoadBalancerInterface> balancer_;
+    std::shared_ptr<etl::NetworkValidatedLedgersInterface> ledgers_;
+    std::shared_ptr<etl::CacheLoader<>> cacheLoader_;
+
+    std::shared_ptr<etl::LedgerFetcherInterface> fetcher_;
+    std::shared_ptr<ExtractorInterface> extractor_;
+
+    etl::SystemState state_;
+    util::async::CoroExecutionContext ctx_{8};
+
+    std::shared_ptr<AmendmentBlockHandlerInterface> amendmentBlockHandler_;
+    std::shared_ptr<impl::Loader> loader_;
+
+    std::optional<util::async::CoroExecutionContext::Operation<void>> mainLoop_;
+
+public:
+    /**
+     * @brief Create an instance of ETLService.
+     *
+     * @param config The configuration to use
+     * @param backend BackendInterface implementation
+     * @param subscriptions Subscription manager
+     * @param balancer Load balancer to use
+     * @param ledgers The network validated ledgers datastructure
+     */
+    ETLService(
+        util::config::ClioConfigDefinition const& config,
+        std::shared_ptr<BackendInterface> backend,
+        std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
+        std::shared_ptr<etlng::LoadBalancerInterface> balancer,
+        std::shared_ptr<etl::NetworkValidatedLedgersInterface> ledgers
+    )
+        : backend_(std::move(backend))
+        , subscriptions_(std::move(subscriptions))
+        , balancer_(std::move(balancer))
+        , ledgers_(std::move(ledgers))
+        , cacheLoader_(std::make_shared<etl::CacheLoader<>>(config, backend_, backend_->cache()))
+        , fetcher_(std::make_shared<etl::impl::LedgerFetcher>(backend_, balancer_))
+        , extractor_(std::make_shared<impl::Extractor>(fetcher_))
+        , amendmentBlockHandler_(std::make_shared<etlng::impl::AmendmentBlockHandler>(ctx_, state_))
+        , loader_(std::make_shared<impl::Loader>(
+              backend_,
+              fetcher_,
+              impl::makeRegistry(
+                  impl::CacheExt{backend_->cache()},
+                  impl::CoreExt{backend_},
+                  impl::SuccessorExt{backend_, backend_->cache()},
+                  impl::NFTExt{backend_}
+              ),
+              amendmentBlockHandler_
+          ))
+    {
+        LOG(log_.info()) << "Creating ETLng...";
+    }
+
+    ~ETLService() override
+    {
+        LOG(log_.debug()) << "Stopping ETLng";
+    }
+
+    void
+    run() override
+    {
+        LOG(log_.info()) << "run() in ETLng...";
+
+        mainLoop_.emplace(ctx_.execute([this] {
+            auto const rng = loadInitialLedgerIfNeeded();
+
+            LOG(log_.info()) << "Waiting for next ledger to be validated by network...";
+            std::optional<uint32_t> mostRecentValidated = ledgers_->getMostRecent();
+
+            if (not mostRecentValidated) {
+                LOG(log_.info()) << "The wait for the next validated ledger has been aborted. "
+                                    "Exiting monitor loop";
+                return;
+            }
+
+            ASSERT(rng.has_value(), "Ledger range can't be null");
+            auto const nextSequence = rng->maxSequence + 1;
+
+            LOG(log_.debug()) << "Database is populated. Starting monitor loop. sequence = " << nextSequence;
+
+            auto scheduler = impl::makeScheduler(impl::ForwardScheduler{*ledgers_, nextSequence}
+                                                 // impl::BackfillScheduler{nextSequence - 1, nextSequence - 1000},
+                                                 // TODO lift limit and start with rng.minSeq
+            );
+
+            auto man = impl::TaskManager(ctx_, *scheduler, *extractor_, *loader_);
+
+            // TODO: figure out this: std::make_shared<impl::Monitor>(backend_, ledgers_, nextSequence)
+            man.run({});  // TODO: needs to be interruptable and fill out settings
+        }));
+    }
+
+    void
+    stop() override
+    {
+        LOG(log_.info()) << "Stop called";
+        // TODO: stop the service correctly
+    }
+
+    boost::json::object
+    getInfo() const override
+    {
+        // TODO
+        return {{"ok", true}};
+    }
+
+    bool
+    isAmendmentBlocked() const override
+    {
+        // TODO
+        return false;
+    }
+
+    bool
+    isCorruptionDetected() const override
+    {
+        // TODO
+        return false;
+    }
+
+    std::optional<etl::ETLState>
+    getETLState() const override
+    {
+        // TODO
+        return std::nullopt;
+    }
+
+    std::uint32_t
+    lastCloseAgeSeconds() const override
+    {
+        // TODO
+        return 0;
+    }
+
+private:
+    // TODO: this better be std::expected
+    std::optional<data::LedgerRange>
+    loadInitialLedgerIfNeeded()
+    {
+        if (auto rng = backend_->hardFetchLedgerRangeNoThrow(); not rng.has_value()) {
+            LOG(log_.info()) << "Database is empty. Will download a ledger from the network.";
+
+            try {
+                LOG(log_.info()) << "Waiting for next ledger to be validated by network...";
+                if (auto const mostRecentValidated = ledgers_->getMostRecent(); mostRecentValidated.has_value()) {
+                    auto const seq = *mostRecentValidated;
+                    LOG(log_.info()) << "Ledger " << seq << " has been validated. Downloading... ";
+
+                    auto [ledger, timeDiff] = ::util::timed<std::chrono::duration<double>>([this, seq]() {
+                        return extractor_->extractLedgerOnly(seq).and_then([this, seq](auto&& data) {
+                            // TODO: loadInitialLedger in balancer should be called fetchEdgeKeys or similar
+                            data.edgeKeys = balancer_->loadInitialLedger(seq, *loader_);
+
+                            // TODO: this should be interruptable for graceful shutdown
+                            return loader_->loadInitialLedger(data);
+                        });
+                    });
+
+                    LOG(log_.debug()) << "Time to download and store ledger = " << timeDiff;
+                    LOG(log_.info()) << "Finished loadInitialLedger. cache size = " << backend_->cache().size();
+
+                    if (ledger.has_value())
+                        return backend_->hardFetchLedgerRangeNoThrow();
+
+                    LOG(log_.error()) << "Failed to load initial ledger. Exiting monitor loop";
+                } else {
+                    LOG(log_.info()) << "The wait for the next validated ledger has been aborted. "
+                                        "Exiting monitor loop";
+                }
+            } catch (std::runtime_error const& e) {
+                LOG(log_.fatal()) << "Failed to load initial ledger: " << e.what();
+                amendmentBlockHandler_->notifyAmendmentBlocked();
+            }
+        } else {
+            LOG(log_.info()) << "Database already populated. Picking up from the tip of history";
+            cacheLoader_->load(rng->maxSequence);
+
+            return rng;
+        }
+
+        return std::nullopt;
+    }
+};
+}  // namespace etlng

src/etlng/ETLServiceInterface.hpp

@@ -0,0 +1,92 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "etl/ETLState.hpp"
+
+#include <boost/json/object.hpp>
+
+#include <cstdint>
+#include <optional>
+
+namespace etlng {
+
+/**
+ * @brief This is a base class for any ETL service implementations.
+ * @note A ETL service is responsible for continuously extracting data from a p2p node, and writing that data to the
+ * databases.
+ */
+struct ETLServiceInterface {
+    virtual ~ETLServiceInterface() = default;
+
+    /**
+     * @brief Start all components to run ETL service.
+     */
+    virtual void
+    run() = 0;
+
+    /**
+     * @brief Stop the ETL service.
+     * @note This method blocks until the ETL service has stopped.
+     */
+    virtual void
+    stop() = 0;
+
+    /**
+     * @brief Get state of ETL as a JSON object
+     *
+     * @return The state of ETL as a JSON object
+     */
+    [[nodiscard]] virtual boost::json::object
+    getInfo() const = 0;
+
+    /**
+     * @brief Check for the amendment blocked state.
+     *
+     * @return true if currently amendment blocked; false otherwise
+     */
+    [[nodiscard]] virtual bool
+    isAmendmentBlocked() const = 0;
+
+    /**
+     * @brief Check whether Clio detected DB corruptions.
+     *
+     * @return true if corruption of DB was detected and cache was stopped.
+     */
+    [[nodiscard]] virtual bool
+    isCorruptionDetected() const = 0;
+
+    /**
+     * @brief Get the etl nodes' state
+     * @return The etl nodes' state, nullopt if etl nodes are not connected
+     */
+    [[nodiscard]] virtual std::optional<etl::ETLState>
+    getETLState() const = 0;
+
+    /**
+     * @brief Get time passed since last ledger close, in seconds.
+     *
+     * @return Time passed since last ledger close
+     */
+    [[nodiscard]] virtual std::uint32_t
+    lastCloseAgeSeconds() const = 0;
+};
+
+}  // namespace etlng

src/etlng/LoadBalancer.cpp

@@ -0,0 +1,371 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2023, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "etlng/LoadBalancer.hpp"
+
+#include "data/BackendInterface.hpp"
+#include "etl/ETLState.hpp"
+#include "etl/NetworkValidatedLedgersInterface.hpp"
+#include "etlng/InitialLoadObserverInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
+#include "etlng/Source.hpp"
+#include "feed/SubscriptionManagerInterface.hpp"
+#include "rpc/Errors.hpp"
+#include "util/Assert.hpp"
+#include "util/CoroutineGroup.hpp"
+#include "util/Random.hpp"
+#include "util/ResponseExpirationCache.hpp"
+#include "util/log/Logger.hpp"
+#include "util/newconfig/ArrayView.hpp"
+#include "util/newconfig/ConfigDefinition.hpp"
+#include "util/newconfig/ObjectView.hpp"
+
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/spawn.hpp>
+#include <boost/json/array.hpp>
+#include <boost/json/object.hpp>
+#include <boost/json/value.hpp>
+#include <boost/json/value_to.hpp>
+#include <fmt/core.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+using namespace util::config;
+
+namespace etlng {
+
+std::shared_ptr<LoadBalancerInterface>
+LoadBalancer::makeLoadBalancer(
+    ClioConfigDefinition const& config,
+    boost::asio::io_context& ioc,
+    std::shared_ptr<BackendInterface> backend,
+    std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
+    std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+    SourceFactory sourceFactory
+)
+{
+    return std::make_shared<LoadBalancer>(
+        config, ioc, std::move(backend), std::move(subscriptions), std::move(validatedLedgers), std::move(sourceFactory)
+    );
+}
+
+LoadBalancer::LoadBalancer(
+    ClioConfigDefinition const& config,
+    boost::asio::io_context& ioc,
+    std::shared_ptr<BackendInterface> backend,
+    std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
+    std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+    SourceFactory sourceFactory
+)
+{
+    auto const forwardingCacheTimeout = config.get<float>("forwarding.cache_timeout");
+    if (forwardingCacheTimeout > 0.f) {
+        forwardingCache_ = util::ResponseExpirationCache{
+            util::config::ClioConfigDefinition::toMilliseconds(forwardingCacheTimeout),
+            {"server_info", "server_state", "server_definitions", "fee", "ledger_closed"}
+        };
+    }
+
+    auto const numMarkers = config.getValueView("num_markers");
+    if (numMarkers.hasValue()) {
+        auto const value = numMarkers.asIntType<uint32_t>();
+        downloadRanges_ = value;
+    } else if (backend->fetchLedgerRange()) {
+        downloadRanges_ = 4;
+    }
+
+    auto const allowNoEtl = config.get<bool>("allow_no_etl");
+
+    auto const checkOnETLFailure = [this, allowNoEtl](std::string const& log) {
+        LOG(log_.warn()) << log;
+
+        if (!allowNoEtl) {
+            LOG(log_.error()) << "Set allow_no_etl as true in config to allow clio run without valid ETL sources.";
+            throw std::logic_error("ETL configuration error.");
+        }
+    };
+
+    auto const forwardingTimeout =
+        ClioConfigDefinition::toMilliseconds(config.get<float>("forwarding.request_timeout"));
+    auto const etlArray = config.getArray("etl_sources");
+    for (auto it = etlArray.begin<ObjectView>(); it != etlArray.end<ObjectView>(); ++it) {
+        auto source = sourceFactory(
+            *it,
+            ioc,
+            subscriptions,
+            validatedLedgers,
+            forwardingTimeout,
+            [this]() {
+                if (not hasForwardingSource_.lock().get())
+                    chooseForwardingSource();
+            },
+            [this](bool wasForwarding) {
+                if (wasForwarding)
+                    chooseForwardingSource();
+            },
+            [this]() {
+                if (forwardingCache_.has_value())
+                    forwardingCache_->invalidate();
+            }
+        );
+
+        // checking etl node validity
+        auto const stateOpt = etl::ETLState::fetchETLStateFromSource(*source);
+
+        if (!stateOpt) {
+            LOG(log_.warn()) << "Failed to fetch ETL state from source = " << source->toString()
+                             << " Please check the configuration and network";
+        } else if (etlState_ && etlState_->networkID && stateOpt->networkID &&
+                   etlState_->networkID != stateOpt->networkID) {
+            checkOnETLFailure(fmt::format(
+                "ETL sources must be on the same network. Source network id = {} does not match others network id = {}",
+                *(stateOpt->networkID),
+                *(etlState_->networkID)
+            ));
+        } else {
+            etlState_ = stateOpt;
+        }
+
+        sources_.push_back(std::move(source));
+        LOG(log_.info()) << "Added etl source - " << sources_.back()->toString();
+    }
+
+    if (!etlState_)
+        checkOnETLFailure("Failed to fetch ETL state from any source. Please check the configuration and network");
+
+    if (sources_.empty())
+        checkOnETLFailure("No ETL sources configured. Please check the configuration");
+
+    // This is made separate from source creation to prevent UB in case one of the sources will call
+    // chooseForwardingSource while we are still filling the sources_ vector
+    for (auto const& source : sources_) {
+        source->run();
+    }
+}
+
+LoadBalancer::~LoadBalancer()
+{
+    sources_.clear();
+}
+
+std::vector<std::string>
+LoadBalancer::loadInitialLedger(
+    uint32_t sequence,
+    etlng::InitialLoadObserverInterface& loadObserver,
+    std::chrono::steady_clock::duration retryAfter
+)
+{
+    std::vector<std::string> response;
+    execute(
+        [this, &response, &sequence, &loadObserver](auto& source) {
+            auto [data, res] = source->loadInitialLedger(sequence, downloadRanges_, loadObserver);
+
+            if (!res) {
+                LOG(log_.error()) << "Failed to download initial ledger."
+                                  << " Sequence = " << sequence << " source = " << source->toString();
+            } else {
+                response = std::move(data);
+            }
+
+            return res;
+        },
+        sequence,
+        retryAfter
+    );
+    return response;
+}
+
+LoadBalancer::OptionalGetLedgerResponseType
+LoadBalancer::fetchLedger(
+    uint32_t ledgerSequence,
+    bool getObjects,
+    bool getObjectNeighbors,
+    std::chrono::steady_clock::duration retryAfter
+)
+{
+    GetLedgerResponseType response;
+    execute(
+        [&response, ledgerSequence, getObjects, getObjectNeighbors, log = log_](auto& source) {
+            auto [status, data] = source->fetchLedger(ledgerSequence, getObjects, getObjectNeighbors);
+            response = std::move(data);
+            if (status.ok() && response.validated()) {
+                LOG(log.info()) << "Successfully fetched ledger = " << ledgerSequence
+                                << " from source = " << source->toString();
+                return true;
+            }
+
+            LOG(log.warn()) << "Could not fetch ledger " << ledgerSequence << ", Reply: " << response.DebugString()
+                            << ", error_code: " << status.error_code() << ", error_msg: " << status.error_message()
+                            << ", source = " << source->toString();
+            return false;
+        },
+        ledgerSequence,
+        retryAfter
+    );
+    return response;
+}
+
+std::expected<boost::json::object, rpc::ClioError>
+LoadBalancer::forwardToRippled(
+    boost::json::object const& request,
+    std::optional<std::string> const& clientIp,
+    bool isAdmin,
+    boost::asio::yield_context yield
+)
+{
+    if (not request.contains("command"))
+        return std::unexpected{rpc::ClioError::RpcCommandIsMissing};
+
+    auto const cmd = boost::json::value_to<std::string>(request.at("command"));
+    if (forwardingCache_) {
+        if (auto cachedResponse = forwardingCache_->get(cmd); cachedResponse) {
+            return std::move(cachedResponse).value();
+        }
+    }
+
+    ASSERT(not sources_.empty(), "ETL sources must be configured to forward requests.");
+    std::size_t sourceIdx = util::Random::uniform(0ul, sources_.size() - 1);
+
+    auto numAttempts = 0u;
+
+    auto xUserValue = isAdmin ? kADMIN_FORWARDING_X_USER_VALUE : kUSER_FORWARDING_X_USER_VALUE;
+
+    std::optional<boost::json::object> response;
+    rpc::ClioError error = rpc::ClioError::EtlConnectionError;
+    while (numAttempts < sources_.size()) {
+        auto res = sources_[sourceIdx]->forwardToRippled(request, clientIp, xUserValue, yield);
+        if (res) {
+            response = std::move(res).value();
+            break;
+        }
+        error = std::max(error, res.error());  // Choose the best result between all sources
+
+        sourceIdx = (sourceIdx + 1) % sources_.size();
+        ++numAttempts;
+    }
+
+    if (response) {
+        if (forwardingCache_ and not response->contains("error"))
+            forwardingCache_->put(cmd, *response);
+        return std::move(response).value();
+    }
+
+    return std::unexpected{error};
+}
+
+boost::json::value
+LoadBalancer::toJson() const
+{
+    boost::json::array ret;
+    for (auto& src : sources_)
+        ret.push_back(src->toJson());
+
+    return ret;
+}
+
+template <typename Func>
+void
+LoadBalancer::execute(Func f, uint32_t ledgerSequence, std::chrono::steady_clock::duration retryAfter)
+{
+    ASSERT(not sources_.empty(), "ETL sources must be configured to execute functions.");
+    size_t sourceIdx = util::Random::uniform(0ul, sources_.size() - 1);
+
+    size_t numAttempts = 0;
+
+    while (true) {
+        auto& source = sources_[sourceIdx];
+
+        LOG(log_.debug()) << "Attempting to execute func. ledger sequence = " << ledgerSequence
+                          << " - source = " << source->toString();
+        // Originally, it was (source->hasLedger(ledgerSequence) || true)
+        /* Sometimes rippled has ledger but doesn't actually know. However,
+        but this does NOT happen in the normal case and is safe to remove
+        This || true is only needed when loading full history standalone */
+        if (source->hasLedger(ledgerSequence)) {
+            bool const res = f(source);
+            if (res) {
+                LOG(log_.debug()) << "Successfully executed func at source = " << source->toString()
+                                  << " - ledger sequence = " << ledgerSequence;
+                break;
+            }
+
+            LOG(log_.warn()) << "Failed to execute func at source = " << source->toString()
+                             << " - ledger sequence = " << ledgerSequence;
+        } else {
+            LOG(log_.warn()) << "Ledger not present at source = " << source->toString()
+                             << " - ledger sequence = " << ledgerSequence;
+        }
+        sourceIdx = (sourceIdx + 1) % sources_.size();
+        numAttempts++;
+        if (numAttempts % sources_.size() == 0) {
+            LOG(log_.info()) << "Ledger sequence " << ledgerSequence
+                             << " is not yet available from any configured sources. Sleeping and trying again";
+            std::this_thread::sleep_for(retryAfter);
+        }
+    }
+}
+
+std::optional<etl::ETLState>
+LoadBalancer::getETLState() noexcept
+{
+    if (!etlState_) {
+        // retry ETLState fetch
+        etlState_ = etl::ETLState::fetchETLStateFromSource(*this);
+    }
+    return etlState_;
+}
+
+void
+LoadBalancer::stop(boost::asio::yield_context yield)
+{
+    util::CoroutineGroup group{yield};
+    std::ranges::for_each(sources_, [&group, yield](auto& source) {
+        group.spawn(yield, [&source](boost::asio::yield_context innerYield) { source->stop(innerYield); });
+    });
+    group.asyncWait(yield);
+}
+
+void
+LoadBalancer::chooseForwardingSource()
+{
+    LOG(log_.info()) << "Choosing a new source to forward subscriptions";
+    auto hasForwardingSourceLock = hasForwardingSource_.lock();
+    hasForwardingSourceLock.get() = false;
+    for (auto& source : sources_) {
+        if (not hasForwardingSourceLock.get() and source->isConnected()) {
+            source->setForwarding(true);
+            hasForwardingSourceLock.get() = true;
+        } else {
+            source->setForwarding(false);
+        }
+    }
+}
+
+}  // namespace etlng

src/etlng/LoadBalancer.hpp

@@ -0,0 +1,271 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2022, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "etl/ETLState.hpp"
+#include "etl/NetworkValidatedLedgersInterface.hpp"
+#include "etlng/InitialLoadObserverInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
+#include "etlng/Source.hpp"
+#include "feed/SubscriptionManagerInterface.hpp"
+#include "rpc/Errors.hpp"
+#include "util/Assert.hpp"
+#include "util/Mutex.hpp"
+#include "util/ResponseExpirationCache.hpp"
+#include "util/log/Logger.hpp"
+#include "util/newconfig/ConfigDefinition.hpp"
+
+#include <boost/asio.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/spawn.hpp>
+#include <boost/json/object.hpp>
+#include <boost/json/value.hpp>
+#include <grpcpp/grpcpp.h>
+#include <org/xrpl/rpc/v1/get_ledger.pb.h>
+#include <org/xrpl/rpc/v1/ledger.pb.h>
+#include <xrpl/proto/org/xrpl/rpc/v1/xrp_ledger.grpc.pb.h>
+
+#include <chrono>
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace etlng {
+
+/**
+ * @brief A tag class to help identify LoadBalancer in templated code.
+ */
+struct LoadBalancerTag {
+    virtual ~LoadBalancerTag() = default;
+};
+
+template <typename T>
+concept SomeLoadBalancer = std::derived_from<T, LoadBalancerTag>;
+
+/**
+ * @brief This class is used to manage connections to transaction processing processes.
+ *
+ * This class spawns a listener for each etl source, which listens to messages on the ledgers stream (to keep track of
+ * which ledgers have been validated by the network, and the range of ledgers each etl source has). This class also
+ * allows requests for ledger data to be load balanced across all possible ETL sources.
+ */
+class LoadBalancer : public etlng::LoadBalancerInterface, LoadBalancerTag {
+public:
+    using RawLedgerObjectType = org::xrpl::rpc::v1::RawLedgerObject;
+    using GetLedgerResponseType = org::xrpl::rpc::v1::GetLedgerResponse;
+    using OptionalGetLedgerResponseType = std::optional<GetLedgerResponseType>;
+
+private:
+    static constexpr std::uint32_t kDEFAULT_DOWNLOAD_RANGES = 16;
+
+    util::Logger log_{"ETL"};
+    // Forwarding cache must be destroyed after sources because sources have a callback to invalidate cache
+    std::optional<util::ResponseExpirationCache> forwardingCache_;
+    std::optional<std::string> forwardingXUserValue_;
+
+    std::vector<SourcePtr> sources_;
+    std::optional<etl::ETLState> etlState_;
+    std::uint32_t downloadRanges_ =
+        kDEFAULT_DOWNLOAD_RANGES; /*< The number of markers to use when downloading initial ledger */
+
+    // Using mutext instead of atomic_bool because choosing a new source to
+    // forward messages should be done with a mutual exclusion otherwise there will be a race condition
+    util::Mutex<bool> hasForwardingSource_{false};
+
+public:
+    /**
+     * @brief Value for the X-User header when forwarding admin requests
+     */
+    static constexpr std::string_view kADMIN_FORWARDING_X_USER_VALUE = "clio_admin";
+
+    /**
+     * @brief Value for the X-User header when forwarding user requests
+     */
+    static constexpr std::string_view kUSER_FORWARDING_X_USER_VALUE = "clio_user";
+
+    /**
+     * @brief Create an instance of the load balancer.
+     *
+     * @param config The configuration to use
+     * @param ioc The io_context to run on
+     * @param backend BackendInterface implementation
+     * @param subscriptions Subscription manager
+     * @param validatedLedgers The network validated ledgers datastructure
+     * @param sourceFactory A factory function to create a source
+     */
+    LoadBalancer(
+        util::config::ClioConfigDefinition const& config,
+        boost::asio::io_context& ioc,
+        std::shared_ptr<BackendInterface> backend,
+        std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
+        std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+        SourceFactory sourceFactory = makeSource
+    );
+
+    /**
+     * @brief A factory function for the load balancer.
+     *
+     * @param config The configuration to use
+     * @param ioc The io_context to run on
+     * @param backend BackendInterface implementation
+     * @param subscriptions Subscription manager
+     * @param validatedLedgers The network validated ledgers datastructure
+     * @param sourceFactory A factory function to create a source
+     * @return A shared pointer to a new instance of LoadBalancer
+     */
+    static std::shared_ptr<LoadBalancerInterface>
+    makeLoadBalancer(
+        util::config::ClioConfigDefinition const& config,
+        boost::asio::io_context& ioc,
+        std::shared_ptr<BackendInterface> backend,
+        std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
+        std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+        SourceFactory sourceFactory = makeSource
+    );
+
+    ~LoadBalancer() override;
+
+    /**
+     * @brief Load the initial ledger, writing data to the queue.
+     * @note This function will retry indefinitely until the ledger is downloaded.
+     *
+     * @param sequence Sequence of ledger to download
+     * @param retryAfter Time to wait between retries (2 seconds by default)
+     * @return A std::vector<std::string> The ledger data
+     */
+    std::vector<std::string>
+    loadInitialLedger(
+        [[maybe_unused]] uint32_t sequence,
+        [[maybe_unused]] std::chrono::steady_clock::duration retryAfter
+    ) override
+    {
+        ASSERT(false, "Not available for new ETL");
+        std::unreachable();
+    };
+
+    /**
+     * @brief Load the initial ledger, writing data to the queue.
+     * @note This function will retry indefinitely until the ledger is downloaded.
+     *
+     * @param sequence Sequence of ledger to download
+     * @param observer The observer to notify of progress
+     * @param retryAfter Time to wait between retries (2 seconds by default)
+     * @return A std::vector<std::string> The ledger data
+     */
+    std::vector<std::string>
+    loadInitialLedger(
+        uint32_t sequence,
+        etlng::InitialLoadObserverInterface& observer,
+        std::chrono::steady_clock::duration retryAfter
+    ) override;
+
+    /**
+     * @brief Fetch data for a specific ledger.
+     *
+     * This function will continuously try to fetch data for the specified ledger until the fetch succeeds, the ledger
+     * is found in the database, or the server is shutting down.
+     *
+     * @param ledgerSequence Sequence of the ledger to fetch
+     * @param getObjects Whether to get the account state diff between this ledger and the prior one
+     * @param getObjectNeighbors Whether to request object neighbors
+     * @param retryAfter Time to wait between retries (2 seconds by default)
+     * @return The extracted data, if extraction was successful. If the ledger was found
+     * in the database or the server is shutting down, the optional will be empty
+     */
+    OptionalGetLedgerResponseType
+    fetchLedger(
+        uint32_t ledgerSequence,
+        bool getObjects,
+        bool getObjectNeighbors,
+        std::chrono::steady_clock::duration retryAfter = std::chrono::seconds{2}
+    ) override;
+
+    /**
+     * @brief Represent the state of this load balancer as a JSON object
+     *
+     * @return JSON representation of the state of this load balancer.
+     */
+    boost::json::value
+    toJson() const override;
+
+    /**
+     * @brief Forward a JSON RPC request to a randomly selected rippled node.
+     *
+     * @param request JSON-RPC request to forward
+     * @param clientIp The IP address of the peer, if known
+     * @param isAdmin Whether the request is from an admin
+     * @param yield The coroutine context
+     * @return Response received from rippled node as JSON object on success or error on failure
+     */
+    std::expected<boost::json::object, rpc::ClioError>
+    forwardToRippled(
+        boost::json::object const& request,
+        std::optional<std::string> const& clientIp,
+        bool isAdmin,
+        boost::asio::yield_context yield
+    ) override;
+
+    /**
+     * @brief Return state of ETL nodes.
+     * @return ETL state, nullopt if etl nodes not available
+     */
+    std::optional<etl::ETLState>
+    getETLState() noexcept override;
+
+    /**
+     * @brief Stop the load balancer. This will stop all subscription sources.
+     * @note This function will asynchronously wait for all sources to stop.
+     *
+     * @param yield The coroutine context
+     */
+    void
+    stop(boost::asio::yield_context yield) override;
+
+private:
+    /**
+     * @brief Execute a function on a randomly selected source.
+     *
+     * @note f is a function that takes an Source as an argument and returns a bool.
+     * Attempt to execute f for one randomly chosen Source that has the specified ledger. If f returns false, another
+     * randomly chosen Source is used. The process repeats until f returns true.
+     *
+     * @param f Function to execute. This function takes the ETL source as an argument, and returns a bool
+     * @param ledgerSequence f is executed for each Source that has this ledger
+     * @param retryAfter Time to wait between retries (2 seconds by default)
+     * server is shutting down
+     */
+    template <typename Func>
+    void
+    execute(Func f, uint32_t ledgerSequence, std::chrono::steady_clock::duration retryAfter = std::chrono::seconds{2});
+
+    /**
+     * @brief Choose a new source to forward requests
+     */
+    void
+    chooseForwardingSource();
+};
+
+}  // namespace etlng

src/etlng/LoadBalancerInterface.hpp

@@ -129,6 +129,15 @@ public:
      */
     virtual std::optional<etl::ETLState>
     getETLState() noexcept = 0;
+
+    /**
+     * @brief Stop the load balancer. This will stop all subscription sources.
+     * @note This function will asynchronously wait for all sources to stop.
+     *
+     * @param yield The coroutine context
+     */
+    virtual void
+    stop(boost::asio::yield_context yield) = 0;
 };
 
 }  // namespace etlng

src/etlng/LoaderInterface.hpp

@@ -45,7 +45,7 @@ struct LoaderInterface {
      * @param data The data to load
      * @return Optional ledger header
      */
-    virtual std::optional<ripple::LedgerHeader>
+    [[nodiscard]] virtual std::optional<ripple::LedgerHeader>
     loadInitialLedger(model::LedgerData const& data) = 0;
 };
 

src/etlng/MonitorInterface.hpp

@@ -0,0 +1,67 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/signal.hpp>
+#include <boost/signals2/variadic_signal.hpp>
+
+#include <chrono>
+#include <cstdint>
+
+namespace etlng {
+
+/**
+ * @brief An interface for the monitor service
+ * An implementation of this service is responsible for periodically checking various datasources to detect newly
+ * ingested ledgers.
+ */
+class MonitorInterface {
+public:
+    static constexpr auto kDEFAULT_REPEAT_INTERVAL = std::chrono::seconds{1};
+    using SignalType = boost::signals2::signal<void(uint32_t)>;
+
+    virtual ~MonitorInterface() = default;
+
+    /**
+     * @brief Allows clients to get notified when a new ledger becomes available in Clio's database
+     *
+     * @param subscriber The slot to connect
+     * @return A connection object that automatically disconnects the subscription once destroyed
+     */
+    [[nodiscard]] virtual boost::signals2::scoped_connection
+    subscribe(SignalType::slot_type const& subscriber) = 0;
+
+    /**
+     * @brief Run the monitor service
+     *
+     * @param repeatInterval The interval between attempts to check the database for new ledgers
+     */
+    virtual void
+    run(std::chrono::steady_clock::duration repeatInterval = kDEFAULT_REPEAT_INTERVAL) = 0;
+
+    /**
+     * @brief Stops the monitor service
+     */
+    virtual void
+    stop() = 0;
+};
+
+}  // namespace etlng

src/etlng/Source.cpp

@@ -0,0 +1,73 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2024, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "etlng/Source.hpp"
+
+#include "etl/NetworkValidatedLedgersInterface.hpp"
+#include "etl/impl/ForwardingSource.hpp"
+#include "etl/impl/SubscriptionSource.hpp"
+#include "etlng/impl/GrpcSource.hpp"
+#include "etlng/impl/SourceImpl.hpp"
+#include "feed/SubscriptionManagerInterface.hpp"
+#include "util/newconfig/ObjectView.hpp"
+
+#include <boost/asio/io_context.hpp>
+
+#include <chrono>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace etlng {
+
+SourcePtr
+makeSource(
+    util::config::ObjectView const& config,
+    boost::asio::io_context& ioc,
+    std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
+    std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+    std::chrono::steady_clock::duration forwardingTimeout,
+    SourceBase::OnConnectHook onConnect,
+    SourceBase::OnDisconnectHook onDisconnect,
+    SourceBase::OnLedgerClosedHook onLedgerClosed
+)
+{
+    auto const ip = config.get<std::string>("ip");
+    auto const wsPort = config.get<std::string>("ws_port");
+    auto const grpcPort = config.get<std::string>("grpc_port");
+
+    etl::impl::ForwardingSource forwardingSource{ip, wsPort, forwardingTimeout};
+    impl::GrpcSource grpcSource{ip, grpcPort};
+    auto subscriptionSource = std::make_unique<etl::impl::SubscriptionSource>(
+        ioc,
+        ip,
+        wsPort,
+        std::move(validatedLedgers),
+        std::move(subscriptions),
+        std::move(onConnect),
+        std::move(onDisconnect),
+        std::move(onLedgerClosed)
+    );
+
+    return std::make_unique<impl::SourceImpl<>>(
+        ip, wsPort, grpcPort, std::move(grpcSource), std::move(subscriptionSource), std::move(forwardingSource)
+    );
+}
+
+}  // namespace etlng

src/etlng/Source.hpp

@@ -0,0 +1,194 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2024, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "etl/NetworkValidatedLedgersInterface.hpp"
+#include "etlng/InitialLoadObserverInterface.hpp"
+#include "feed/SubscriptionManagerInterface.hpp"
+#include "rpc/Errors.hpp"
+#include "util/newconfig/ObjectView.hpp"
+
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/spawn.hpp>
+#include <boost/json/object.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <grpcpp/support/status.h>
+#include <org/xrpl/rpc/v1/get_ledger.pb.h>
+
+#include <chrono>
+#include <cstdint>
+#include <expected>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace etlng {
+
+/**
+ * @brief Provides an implementation of a ETL source
+ */
+class SourceBase {
+public:
+    using OnConnectHook = std::function<void()>;
+    using OnDisconnectHook = std::function<void(bool)>;
+    using OnLedgerClosedHook = std::function<void()>;
+
+    virtual ~SourceBase() = default;
+
+    /**
+     * @brief Run subscriptions loop of the source
+     */
+    virtual void
+    run() = 0;
+
+    /**
+     * @brief Stop Source.
+     * @note This method will asynchronously wait for source to be stopped.
+     *
+     * @param yield The coroutine context.
+     */
+    virtual void
+    stop(boost::asio::yield_context yield) = 0;
+
+    /**
+     * @brief Check if source is connected
+     *
+     * @return true if source is connected; false otherwise
+     */
+    [[nodiscard]] virtual bool
+    isConnected() const = 0;
+
+    /**
+     * @brief Set the forwarding state of the source.
+     *
+     * @param isForwarding Whether to forward or not
+     */
+    virtual void
+    setForwarding(bool isForwarding) = 0;
+
+    /**
+     * @brief Represent the source as a JSON object
+     *
+     * @return JSON representation of the source
+     */
+    [[nodiscard]] virtual boost::json::object
+    toJson() const = 0;
+
+    /** @return String representation of the source (for debug) */
+    [[nodiscard]] virtual std::string
+    toString() const = 0;
+
+    /**
+     * @brief Check if ledger is known by this source.
+     *
+     * @param sequence The ledger sequence to check
+     * @return true if ledger is in the range of this source; false otherwise
+     */
+    [[nodiscard]] virtual bool
+    hasLedger(uint32_t sequence) const = 0;
+
+    /**
+     * @brief Fetch data for a specific ledger.
+     *
+     * This function will continuously try to fetch data for the specified ledger until the fetch succeeds, the ledger
+     * is found in the database, or the server is shutting down.
+     *
+     * @param sequence Sequence of the ledger to fetch
+     * @param getObjects Whether to get the account state diff between this ledger and the prior one; defaults to true
+     * @param getObjectNeighbors Whether to request object neighbors; defaults to false
+     * @return A std::pair of the response status and the response itself
+     */
+    [[nodiscard]] virtual std::pair<grpc::Status, org::xrpl::rpc::v1::GetLedgerResponse>
+    fetchLedger(uint32_t sequence, bool getObjects = true, bool getObjectNeighbors = false) = 0;
+
+    /**
+     * @brief Download a ledger in full.
+     *
+     * @param sequence Sequence of the ledger to download
+     * @param numMarkers Number of markers to generate for async calls
+     * @param loader InitialLoadObserverInterface implementation
+     * @return A std::pair of the data and a bool indicating whether the download was successful
+     */
+    virtual std::pair<std::vector<std::string>, bool>
+    loadInitialLedger(uint32_t sequence, std::uint32_t numMarkers, etlng::InitialLoadObserverInterface& loader) = 0;
+
+    /**
+     * @brief Forward a request to rippled.
+     *
+     * @param request The request to forward
+     * @param forwardToRippledClientIp IP of the client forwarding this request if known
+     * @param xUserValue Value of the X-User header
+     * @param yield The coroutine context
+     * @return Response on success or error on failure
+     */
+    [[nodiscard]] virtual std::expected<boost::json::object, rpc::ClioError>
+    forwardToRippled(
+        boost::json::object const& request,
+        std::optional<std::string> const& forwardToRippledClientIp,
+        std::string_view xUserValue,
+        boost::asio::yield_context yield
+    ) const = 0;
+};
+
+using SourcePtr = std::unique_ptr<SourceBase>;
+
+using SourceFactory = std::function<SourcePtr(
+    util::config::ObjectView const& config,
+    boost::asio::io_context& ioc,
+    std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
+    std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+    std::chrono::steady_clock::duration forwardingTimeout,
+    SourceBase::OnConnectHook onConnect,
+    SourceBase::OnDisconnectHook onDisconnect,
+    SourceBase::OnLedgerClosedHook onLedgerClosed
+)>;
+
+/**
+ * @brief Create a source
+ *
+ * @param config The configuration to use
+ * @param ioc The io_context to run on
+ * @param subscriptions Subscription manager
+ * @param validatedLedgers The network validated ledgers data structure
+ * @param forwardingTimeout The timeout for forwarding to rippled
+ * @param onConnect The hook to call on connect
+ * @param onDisconnect The hook to call on disconnect
+ * @param onLedgerClosed The hook to call on ledger closed. This is called when a ledger is closed and the source is set
+ * as forwarding.
+ * @return The created source
+ */
+[[nodiscard]] SourcePtr
+makeSource(
+    util::config::ObjectView const& config,
+    boost::asio::io_context& ioc,
+    std::shared_ptr<feed::SubscriptionManagerInterface> subscriptions,
+    std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+    std::chrono::steady_clock::duration forwardingTimeout,
+    SourceBase::OnConnectHook onConnect,
+    SourceBase::OnDisconnectHook onDisconnect,
+    SourceBase::OnLedgerClosedHook onLedgerClosed
+);
+
+}  // namespace etlng

src/etlng/impl/ForwardingSource.cpp

@@ -0,0 +1,116 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2024, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "etlng/impl/ForwardingSource.hpp"
+
+#include "rpc/Errors.hpp"
+#include "util/log/Logger.hpp"
+
+#include <boost/asio/spawn.hpp>
+#include <boost/beast/http/field.hpp>
+#include <boost/beast/version.hpp>
+#include <boost/json/object.hpp>
+#include <boost/json/parse.hpp>
+#include <boost/json/serialize.hpp>
+#include <fmt/core.h>
+
+#include <chrono>
+#include <exception>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace etlng::impl {
+
+ForwardingSource::ForwardingSource(
+    std::string ip,
+    std::string wsPort,
+    std::chrono::steady_clock::duration forwardingTimeout,
+    std::chrono::steady_clock::duration connTimeout
+)
+    : log_(fmt::format("ForwardingSource[{}:{}]", ip, wsPort))
+    , connectionBuilder_(std::move(ip), std::move(wsPort))
+    , forwardingTimeout_{forwardingTimeout}
+{
+    connectionBuilder_.setConnectionTimeout(connTimeout)
+        .addHeader(
+            {boost::beast::http::field::user_agent, fmt::format("{} websocket-client-coro", BOOST_BEAST_VERSION_STRING)}
+        );
+}
+
+std::expected<boost::json::object, rpc::ClioError>
+ForwardingSource::forwardToRippled(
+    boost::json::object const& request,
+    std::optional<std::string> const& forwardToRippledClientIp,
+    std::string_view xUserValue,
+    boost::asio::yield_context yield
+) const
+{
+    auto connectionBuilder = connectionBuilder_;
+    if (forwardToRippledClientIp) {
+        connectionBuilder.addHeader(
+            {boost::beast::http::field::forwarded, fmt::format("for={}", *forwardToRippledClientIp)}
+        );
+    }
+
+    connectionBuilder.addHeader({"X-User", std::string{xUserValue}});
+
+    auto expectedConnection = connectionBuilder.connect(yield);
+    if (not expectedConnection) {
+        LOG(log_.debug()) << "Couldn't connect to rippled to forward request.";
+        return std::unexpected{rpc::ClioError::EtlConnectionError};
+    }
+    auto& connection = expectedConnection.value();
+
+    auto writeError = connection->write(boost::json::serialize(request), yield, forwardingTimeout_);
+    if (writeError) {
+        LOG(log_.debug()) << "Error sending request to rippled to forward request.";
+        return std::unexpected{rpc::ClioError::EtlRequestError};
+    }
+
+    auto response = connection->read(yield, forwardingTimeout_);
+    if (not response) {
+        if (auto errorCode = response.error().errorCode();
+            errorCode.has_value() and errorCode->value() == boost::system::errc::timed_out) {
+            LOG(log_.debug()) << "Request to rippled timed out";
+            return std::unexpected{rpc::ClioError::EtlRequestTimeout};
+        }
+        LOG(log_.debug()) << "Error sending request to rippled to forward request.";
+        return std::unexpected{rpc::ClioError::EtlRequestError};
+    }
+
+    boost::json::value parsedResponse;
+    try {
+        parsedResponse = boost::json::parse(*response);
+        if (not parsedResponse.is_object())
+            throw std::runtime_error("response is not an object");
+    } catch (std::exception const& e) {
+        LOG(log_.debug()) << "Error parsing response from rippled: " << e.what() << ". Response: " << *response;
+        return std::unexpected{rpc::ClioError::EtlInvalidResponse};
+    }
+
+    auto responseObject = parsedResponse.as_object();
+    responseObject["forwarded"] = true;
+
+    return responseObject;
+}
+
+}  // namespace etlng::impl

src/etlng/impl/ForwardingSource.hpp

@@ -0,0 +1,70 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2024, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "rpc/Errors.hpp"
+#include "util/log/Logger.hpp"
+#include "util/requests/WsConnection.hpp"
+
+#include <boost/asio/spawn.hpp>
+#include <boost/json/object.hpp>
+
+#include <chrono>
+#include <expected>
+#include <optional>
+#include <string>
+#include <string_view>
+
+namespace etlng::impl {
+
+class ForwardingSource {
+    util::Logger log_;
+    util::requests::WsConnectionBuilder connectionBuilder_;
+    std::chrono::steady_clock::duration forwardingTimeout_;
+
+    static constexpr std::chrono::seconds kCONNECTION_TIMEOUT{3};
+
+public:
+    ForwardingSource(
+        std::string ip,
+        std::string wsPort,
+        std::chrono::steady_clock::duration forwardingTimeout,
+        std::chrono::steady_clock::duration connTimeout = ForwardingSource::kCONNECTION_TIMEOUT
+    );
+
+    /**
+     * @brief Forward a request to rippled.
+     *
+     * @param request The request to forward
+     * @param forwardToRippledClientIp IP of the client forwarding this request if known
+     * @param xUserValue Optional value for X-User header
+     * @param yield The coroutine context
+     * @return Response on success or error on failure
+     */
+    std::expected<boost::json::object, rpc::ClioError>
+    forwardToRippled(
+        boost::json::object const& request,
+        std::optional<std::string> const& forwardToRippledClientIp,
+        std::string_view xUserValue,
+        boost::asio::yield_context yield
+    ) const;
+};
+
+}  // namespace etlng::impl

src/etlng/impl/Loading.hpp

@@ -39,7 +39,6 @@
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/TxMeta.h>
 
-#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <optional>

src/etlng/impl/Monitor.cpp

@@ -0,0 +1,99 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "etlng/impl/Monitor.hpp"
+
+#include "data/BackendInterface.hpp"
+#include "etl/NetworkValidatedLedgersInterface.hpp"
+#include "util/Assert.hpp"
+#include "util/async/AnyExecutionContext.hpp"
+#include "util/async/AnyOperation.hpp"
+#include "util/log/Logger.hpp"
+
+#include <boost/signals2/connection.hpp>
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <utility>
+
+namespace etlng::impl {
+Monitor::Monitor(
+    util::async::AnyExecutionContext ctx,
+    std::shared_ptr<BackendInterface> backend,
+    std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+    uint32_t startSequence
+)
+    : strand_(ctx.makeStrand())
+    , backend_(std::move(backend))
+    , validatedLedgers_(std::move(validatedLedgers))
+    , nextSequence_(startSequence)
+{
+}
+
+Monitor::~Monitor()
+{
+    stop();
+}
+
+void
+Monitor::run(std::chrono::steady_clock::duration repeatInterval)
+{
+    ASSERT(not repeatedTask_.has_value(), "Monitor attempted to run more than once");
+    LOG(log_.debug()) << "Starting monitor";
+
+    repeatedTask_ = strand_.executeRepeatedly(repeatInterval, std::bind_front(&Monitor::doWork, this));
+    subscription_ = validatedLedgers_->subscribe(std::bind_front(&Monitor::onNextSequence, this));
+}
+
+void
+Monitor::stop()
+{
+    if (repeatedTask_.has_value())
+        repeatedTask_->abort();
+
+    repeatedTask_ = std::nullopt;
+}
+
+boost::signals2::scoped_connection
+Monitor::subscribe(SignalType::slot_type const& subscriber)
+{
+    return notificationChannel_.connect(subscriber);
+}
+
+void
+Monitor::onNextSequence(uint32_t seq)
+{
+    LOG(log_.debug()) << "rippled published sequence " << seq;
+    repeatedTask_->invoke();  // force-invoke immediately
+}
+
+void
+Monitor::doWork()
+{
+    if (auto rng = backend_->hardFetchLedgerRangeNoThrow(); rng) {
+        while (rng->maxSequence >= nextSequence_)
+            notificationChannel_(nextSequence_++);
+    }
+}
+
+}  // namespace etlng::impl

src/etlng/impl/Monitor.hpp

@@ -0,0 +1,80 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "etl/NetworkValidatedLedgersInterface.hpp"
+#include "etlng/MonitorInterface.hpp"
+#include "util/async/AnyExecutionContext.hpp"
+#include "util/async/AnyOperation.hpp"
+#include "util/async/AnyStrand.hpp"
+#include "util/log/Logger.hpp"
+
+#include <boost/signals2/connection.hpp>
+#include <xrpl/protocol/TxFormats.h>
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+namespace etlng::impl {
+
+class Monitor : public MonitorInterface {
+    util::async::AnyStrand strand_;
+    std::shared_ptr<BackendInterface> backend_;
+    std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers_;
+
+    uint32_t nextSequence_;
+    std::optional<util::async::AnyOperation<void>> repeatedTask_;
+    std::optional<boost::signals2::scoped_connection> subscription_;  // network validated ledgers subscription
+
+    SignalType notificationChannel_;
+
+    util::Logger log_{"ETL"};
+
+public:
+    Monitor(
+        util::async::AnyExecutionContext ctx,
+        std::shared_ptr<BackendInterface> backend,
+        std::shared_ptr<etl::NetworkValidatedLedgersInterface> validatedLedgers,
+        uint32_t startSequence
+    );
+    ~Monitor() override;
+
+    void
+    run(std::chrono::steady_clock::duration repeatInterval) override;
+
+    void
+    stop() override;
+
+    boost::signals2::scoped_connection
+    subscribe(SignalType::slot_type const& subscriber) override;
+
+private:
+    void
+    onNextSequence(uint32_t seq);
+
+    void
+    doWork();
+};
+
+}  // namespace etlng::impl

src/etlng/impl/Registry.hpp

@@ -24,7 +24,6 @@
 
 #include <xrpl/protocol/TxFormats.h>
 
-#include <concepts>
 #include <cstdint>
 #include <string>
 #include <tuple>
@@ -81,7 +80,7 @@ concept ContainsValidHook = HasLedgerDataHook<T> or HasInitialDataHook<T> or
 
 template <typename T>
 concept NoTwoOfKind = not(HasLedgerDataHook<T> and HasTransactionHook<T>) and
-    not(HasInitialDataHook<T> and HasInitialTransactionHook<T>) and not(HasInitialDataHook<T> and HasObjectHook<T>) and
+    not(HasInitialDataHook<T> and HasInitialTransactionHook<T>) and
     not(HasInitialObjectsHook<T> and HasInitialObjectHook<T>);
 
 template <typename T>
@@ -216,4 +215,10 @@ public:
     }
 };
 
+static auto
+makeRegistry(auto&&... exts)
+{
+    return std::make_unique<Registry<std::decay_t<decltype(exts)>...>>(std::forward<decltype(exts)>(exts)...);
+}
+
 }  // namespace etlng::impl

src/etlng/impl/SourceImpl.hpp

@@ -0,0 +1,232 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2024, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "etl/impl/ForwardingSource.hpp"
+#include "etl/impl/SubscriptionSource.hpp"
+#include "etlng/InitialLoadObserverInterface.hpp"
+#include "etlng/Source.hpp"
+#include "etlng/impl/GrpcSource.hpp"
+#include "rpc/Errors.hpp"
+
+#include <boost/asio/spawn.hpp>
+#include <boost/json/object.hpp>
+#include <grpcpp/support/status.h>
+#include <org/xrpl/rpc/v1/get_ledger.pb.h>
+
+#include <chrono>
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace etlng::impl {
+
+/**
+ * @brief Provides an implementation of a ETL source
+ *
+ * @tparam GrpcSourceType The type of the gRPC source
+ * @tparam SubscriptionSourceTypePtr The type of the subscription source
+ * @tparam ForwardingSourceType The type of the forwarding source
+ */
+template <
+    typename GrpcSourceType = GrpcSource,
+    typename SubscriptionSourceTypePtr = std::unique_ptr<etl::impl::SubscriptionSource>,
+    typename ForwardingSourceType = etl::impl::ForwardingSource>
+class SourceImpl : public SourceBase {
+    std::string ip_;
+    std::string wsPort_;
+    std::string grpcPort_;
+
+    GrpcSourceType grpcSource_;
+    SubscriptionSourceTypePtr subscriptionSource_;
+    ForwardingSourceType forwardingSource_;
+
+public:
+    /**
+     * @brief Construct a new SourceImpl object
+     *
+     * @param ip The IP of the source
+     * @param wsPort The web socket port of the source
+     * @param grpcPort The gRPC port of the source
+     * @param grpcSource The gRPC source
+     * @param subscriptionSource The subscription source
+     * @param forwardingSource The forwarding source
+     */
+    template <typename SomeGrpcSourceType, typename SomeForwardingSourceType>
+        requires std::is_same_v<GrpcSourceType, SomeGrpcSourceType> and
+                     std::is_same_v<ForwardingSourceType, SomeForwardingSourceType>
+    SourceImpl(
+        std::string ip,
+        std::string wsPort,
+        std::string grpcPort,
+        SomeGrpcSourceType&& grpcSource,
+        SubscriptionSourceTypePtr subscriptionSource,
+        SomeForwardingSourceType&& forwardingSource
+    )
+        : ip_(std::move(ip))
+        , wsPort_(std::move(wsPort))
+        , grpcPort_(std::move(grpcPort))
+        , grpcSource_(std::forward<SomeGrpcSourceType>(grpcSource))
+        , subscriptionSource_(std::move(subscriptionSource))
+        , forwardingSource_(std::forward<SomeForwardingSourceType>(forwardingSource))
+    {
+    }
+
+    /**
+     * @brief Run subscriptions loop of the source
+     */
+    void
+    run() final
+    {
+        subscriptionSource_->run();
+    }
+
+    void
+    stop(boost::asio::yield_context yield) final
+    {
+        subscriptionSource_->stop(yield);
+    }
+
+    /**
+     * @brief Check if source is connected
+     *
+     * @return true if source is connected; false otherwise
+     */
+    bool
+    isConnected() const final
+    {
+        return subscriptionSource_->isConnected();
+    }
+
+    /**
+     * @brief Set the forwarding state of the source.
+     *
+     * @param isForwarding Whether to forward or not
+     */
+    void
+    setForwarding(bool isForwarding) final
+    {
+        subscriptionSource_->setForwarding(isForwarding);
+    }
+
+    /**
+     * @brief Represent the source as a JSON object
+     *
+     * @return JSON representation of the source
+     */
+    boost::json::object
+    toJson() const final
+    {
+        boost::json::object res;
+
+        res["validated_range"] = subscriptionSource_->validatedRange();
+        res["is_connected"] = std::to_string(static_cast<int>(subscriptionSource_->isConnected()));
+        res["ip"] = ip_;
+        res["ws_port"] = wsPort_;
+        res["grpc_port"] = grpcPort_;
+
+        auto last = subscriptionSource_->lastMessageTime();
+        if (last.time_since_epoch().count() != 0) {
+            res["last_msg_age_seconds"] = std::to_string(
+                std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - last).count()
+            );
+        }
+
+        return res;
+    }
+
+    /** @return String representation of the source (for debug) */
+    std::string
+    toString() const final
+    {
+        return "{validated range: " + subscriptionSource_->validatedRange() + ", ip: " + ip_ +
+            ", web socket port: " + wsPort_ + ", grpc port: " + grpcPort_ + "}";
+    }
+
+    /**
+     * @brief Check if ledger is known by this source.
+     *
+     * @param sequence The ledger sequence to check
+     * @return true if ledger is in the range of this source; false otherwise
+     */
+    bool
+    hasLedger(uint32_t sequence) const final
+    {
+        return subscriptionSource_->hasLedger(sequence);
+    }
+
+    /**
+     * @brief Fetch data for a specific ledger.
+     *
+     * This function will continuously try to fetch data for the specified ledger until the fetch succeeds, the ledger
+     * is found in the database, or the server is shutting down.
+     *
+     * @param sequence Sequence of the ledger to fetch
+     * @param getObjects Whether to get the account state diff between this ledger and the prior one; defaults to true
+     * @param getObjectNeighbors Whether to request object neighbors; defaults to false
+     * @return A std::pair of the response status and the response itself
+     */
+    std::pair<grpc::Status, org::xrpl::rpc::v1::GetLedgerResponse>
+    fetchLedger(uint32_t sequence, bool getObjects = true, bool getObjectNeighbors = false) final
+    {
+        return grpcSource_.fetchLedger(sequence, getObjects, getObjectNeighbors);
+    }
+
+    /**
+     * @brief Download a ledger in full.
+     *
+     * @param sequence Sequence of the ledger to download
+     * @param numMarkers Number of markers to generate for async calls
+     * @param loader InitialLoadObserverInterface implementation
+     * @return A std::pair of the data and a bool indicating whether the download was successful
+     */
+    std::pair<std::vector<std::string>, bool>
+    loadInitialLedger(uint32_t sequence, std::uint32_t numMarkers, etlng::InitialLoadObserverInterface& loader) final
+    {
+        return grpcSource_.loadInitialLedger(sequence, numMarkers, loader);
+    }
+
+    /**
+     * @brief Forward a request to rippled.
+     *
+     * @param request The request to forward
+     * @param forwardToRippledClientIp IP of the client forwarding this request if known
+     * @param xUserValue Optional value of the X-User header
+     * @param yield The coroutine context
+     * @return Response or ClioError
+     */
+    std::expected<boost::json::object, rpc::ClioError>
+    forwardToRippled(
+        boost::json::object const& request,
+        std::optional<std::string> const& forwardToRippledClientIp,
+        std::string_view xUserValue,
+        boost::asio::yield_context yield
+    ) const final
+    {
+        return forwardingSource_.forwardToRippled(request, forwardToRippledClientIp, xUserValue, yield);
+    }
+};
+
+}  // namespace etlng::impl

src/etlng/impl/ext/Cache.cpp

@@ -0,0 +1,59 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "etlng/impl/ext/Cache.hpp"
+
+#include "data/LedgerCacheInterface.hpp"
+#include "etlng/Models.hpp"
+#include "util/log/Logger.hpp"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace etlng::impl {
+
+CacheExt::CacheExt(data::LedgerCacheInterface& cache) : cache_(cache)
+{
+}
+
+void
+CacheExt::onLedgerData(model::LedgerData const& data) const
+{
+    cache_.get().update(data.objects, data.seq);
+    LOG(log_.trace()) << "got data. objects cnt = " << data.objects.size();
+}
+
+void
+CacheExt::onInitialData(model::LedgerData const& data) const
+{
+    LOG(log_.trace()) << "got initial data. objects cnt = " << data.objects.size();
+    cache_.get().update(data.objects, data.seq);
+    cache_.get().setFull();
+}
+
+void
+CacheExt::onInitialObjects(uint32_t seq, std::vector<model::Object> const& objs, [[maybe_unused]] std::string lastKey)
+    const
+{
+    LOG(log_.trace()) << "got initial objects cnt = " << objs.size();
+    cache_.get().update(objs, seq);
+}
+
+}  // namespace etlng::impl

src/etlng/impl/ext/Cache.hpp

@@ -0,0 +1,51 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/LedgerCacheInterface.hpp"
+#include "etlng/Models.hpp"
+#include "util/log/Logger.hpp"
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace etlng::impl {
+
+class CacheExt {
+    std::reference_wrapper<data::LedgerCacheInterface> cache_;
+
+    util::Logger log_{"ETL"};
+
+public:
+    CacheExt(data::LedgerCacheInterface& cache);
+
+    void
+    onLedgerData(model::LedgerData const& data) const;
+
+    void
+    onInitialData(model::LedgerData const& data) const;
+
+    void
+    onInitialObjects(uint32_t seq, std::vector<model::Object> const& objs, [[maybe_unused]] std::string lastKey) const;
+};
+
+}  // namespace etlng::impl

src/etlng/impl/ext/Core.cpp

@@ -0,0 +1,83 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "etlng/impl/ext/Core.hpp"
+
+#include "data/BackendInterface.hpp"
+#include "etlng/Models.hpp"
+#include "util/log/Logger.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace etlng::impl {
+
+CoreExt::CoreExt(std::shared_ptr<BackendInterface> backend) : backend_(std::move(backend))
+{
+}
+
+void
+CoreExt::onLedgerData(model::LedgerData const& data) const
+{
+    LOG(log_.debug()) << "Loading ledger data for " << data.seq;
+    backend_->writeLedger(data.header, auto{data.rawHeader});
+    insertTransactions(data);
+}
+
+void
+CoreExt::onInitialData(model::LedgerData const& data) const
+{
+    LOG(log_.info()) << "Loading initial ledger data for " << data.seq;
+    backend_->writeLedger(data.header, auto{data.rawHeader});
+    insertTransactions(data);
+}
+
+void
+CoreExt::onInitialObject(uint32_t seq, model::Object const& obj) const
+{
+    LOG(log_.trace()) << "got initial OBJ = " << obj.key << " for seq " << seq;
+    backend_->writeLedgerObject(auto{obj.keyRaw}, seq, auto{obj.dataRaw});
+}
+
+void
+CoreExt::onObject(uint32_t seq, model::Object const& obj) const
+{
+    LOG(log_.trace()) << "got OBJ = " << obj.key << " for seq " << seq;
+    backend_->writeLedgerObject(auto{obj.keyRaw}, seq, auto{obj.dataRaw});
+}
+
+void
+CoreExt::insertTransactions(model::LedgerData const& data) const
+{
+    for (auto const& txn : data.transactions) {
+        LOG(log_.trace()) << "Inserting transaction = " << txn.sttx.getTransactionID();
+
+        backend_->writeAccountTransaction({txn.meta, txn.sttx.getTransactionID()});
+        backend_->writeTransaction(
+            auto{txn.key},
+            data.seq,
+            data.header.closeTime.time_since_epoch().count(),  // This is why we can't use 'onTransaction'
+            auto{txn.raw},
+            auto{txn.metaRaw}
+        );
+    }
+}
+
+}  // namespace etlng::impl

src/etlng/impl/ext/Core.hpp

@@ -0,0 +1,58 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "etlng/Models.hpp"
+#include "util/log/Logger.hpp"
+
+#include <xrpl/basics/base_uint.h>
+
+#include <cstdint>
+#include <memory>
+
+namespace etlng::impl {
+
+class CoreExt {
+    std::shared_ptr<BackendInterface> backend_;
+
+    util::Logger log_{"ETL"};
+
+public:
+    CoreExt(std::shared_ptr<BackendInterface> backend);
+
+    void
+    onLedgerData(model::LedgerData const& data) const;
+
+    void
+    onInitialData(model::LedgerData const& data) const;
+
+    void
+    onInitialObject(uint32_t seq, model::Object const& obj) const;
+
+    void
+    onObject(uint32_t seq, model::Object const& obj) const;
+
+private:
+    void
+    insertTransactions(model::LedgerData const& data) const;
+};
+
+}  // namespace etlng::impl

src/etlng/impl/ext/NFT.cpp

@@ -0,0 +1,77 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "etlng/impl/ext/NFT.hpp"
+
+#include "data/BackendInterface.hpp"
+#include "data/DBHelpers.hpp"
+#include "etl/NFTHelpers.hpp"
+#include "etlng/Models.hpp"
+#include "util/log/Logger.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace etlng::impl {
+
+NFTExt::NFTExt(std::shared_ptr<BackendInterface> backend) : backend_(std::move(backend))
+{
+}
+
+void
+NFTExt::onLedgerData(model::LedgerData const& data) const
+{
+    writeNFTs(data);
+}
+
+void
+NFTExt::onInitialObject(uint32_t seq, model::Object const& obj) const
+{
+    LOG(log_.trace()) << "got initial object with key = " << obj.key;
+    backend_->writeNFTs(etl::getNFTDataFromObj(seq, obj.keyRaw, obj.dataRaw));
+}
+
+void
+NFTExt::onInitialData(model::LedgerData const& data) const
+{
+    LOG(log_.trace()) << "got initial TXS cnt = " << data.transactions.size();
+    writeNFTs(data);
+}
+
+void
+NFTExt::writeNFTs(model::LedgerData const& data) const
+{
+    std::vector<NFTsData> nfts;
+    std::vector<NFTTransactionsData> nftTxs;
+
+    for (auto const& tx : data.transactions) {
+        auto const [txs, maybeNFT] = etl::getNFTDataFromTx(tx.meta, tx.sttx);
+        nftTxs.insert(nftTxs.end(), txs.begin(), txs.end());
+        if (maybeNFT)
+            nfts.push_back(*maybeNFT);
+    }
+
+    // This is uniqued so that we only write latest modification (as in previous implementation)
+    backend_->writeNFTs(etl::getUniqueNFTsDatas(nfts));
+    backend_->writeNFTTransactions(nftTxs);
+}
+
+}  // namespace etlng::impl

src/etlng/impl/ext/NFT.hpp

@@ -0,0 +1,52 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "etlng/Models.hpp"
+#include "util/log/Logger.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace etlng::impl {
+
+class NFTExt {
+    std::shared_ptr<BackendInterface> backend_;
+    util::Logger log_{"ETL"};
+
+public:
+    NFTExt(std::shared_ptr<BackendInterface> backend);
+
+    void
+    onLedgerData(model::LedgerData const& data) const;
+
+    void
+    onInitialObject(uint32_t seq, model::Object const& obj) const;
+
+    void
+    onInitialData(model::LedgerData const& data) const;
+
+private:
+    void
+    writeNFTs(model::LedgerData const& data) const;
+};
+
+}  // namespace etlng::impl

src/etlng/impl/ext/Successor.cpp

@@ -0,0 +1,222 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "etlng/impl/ext/Successor.hpp"
+
+#include "data/BackendInterface.hpp"
+#include "data/DBHelpers.hpp"
+#include "data/LedgerCacheInterface.hpp"
+#include "data/Types.hpp"
+#include "etlng/Models.hpp"
+#include "util/Assert.hpp"
+#include "util/log/Logger.hpp"
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/strHex.h>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace etlng::impl {
+
+SuccessorExt::SuccessorExt(std::shared_ptr<BackendInterface> backend, data::LedgerCacheInterface& cache)
+    : backend_(std::move(backend)), cache_(cache)
+{
+}
+
+void
+SuccessorExt::onInitialData(model::LedgerData const& data) const
+{
+    ASSERT(cache_.get().isFull(), "Cache must be full at this point");
+    ASSERT(data.edgeKeys.has_value(), "Expecting to have edge keys on initial data load");
+    ASSERT(data.objects.empty(), "Should not have objects from initial data");
+    writeSuccessors(data.seq);
+    writeEdgeKeys(data.seq, data.edgeKeys.value());
+}
+
+void
+SuccessorExt::onInitialObjects(
+    uint32_t seq,
+    [[maybe_unused]] std::vector<model::Object> const& objs,
+    std::string lastKey
+) const
+{
+    for (auto const& obj : objs) {
+        if (!lastKey.empty())
+            backend_->writeSuccessor(std::move(lastKey), seq, auto{obj.keyRaw});
+        lastKey = obj.keyRaw;
+    }
+}
+
+void
+SuccessorExt::onLedgerData(model::LedgerData const& data) const
+{
+    namespace vs = std::views;
+
+    LOG(log_.info()) << "Received ledger data for successor ext; obj cnt = " << data.objects.size()
+                     << "; got successors = " << data.successors.has_value() << "; cache is "
+                     << (cache_.get().isFull() ? "FULL" : "Not full");
+
+    auto filteredObjects = data.objects  //
+        | vs::filter([](auto const& obj) { return obj.type != model::Object::ModType::Modified; });
+
+    if (data.successors.has_value()) {
+        for (auto const& successor : data.successors.value())
+            writeIncludedSuccessor(data.seq, successor);
+
+        for (auto const& obj : filteredObjects)
+            writeIncludedSuccessor(data.seq, obj);
+    } else {
+        if (not cache_.get().isFull() or cache_.get().latestLedgerSequence() != data.seq)
+            throw std::logic_error("Cache is not full, but object neighbors were not included");
+
+        for (auto const& obj : filteredObjects)
+            updateSuccessorFromCache(data.seq, obj);
+    }
+}
+
+void
+SuccessorExt::writeIncludedSuccessor(uint32_t seq, model::BookSuccessor const& succ) const
+{
+    auto firstBook = succ.firstBook;
+    if (firstBook.empty())
+        firstBook = uint256ToString(data::kLAST_KEY);
+
+    backend_->writeSuccessor(auto{succ.bookBase}, seq, std::move(firstBook));
+}
+
+void
+SuccessorExt::writeIncludedSuccessor(uint32_t seq, model::Object const& obj) const
+{
+    ASSERT(obj.type != model::Object::ModType::Modified, "Attempt to write successor for a modified object");
+
+    // TODO: perhaps make these optionals inside of obj and move value_or here
+    auto pred = obj.predecessor;
+    auto succ = obj.successor;
+
+    if (obj.type == model::Object::ModType::Deleted) {
+        backend_->writeSuccessor(std::move(pred), seq, std::move(succ));
+    } else if (obj.type == model::Object::ModType::Created) {
+        backend_->writeSuccessor(std::move(pred), seq, auto{obj.keyRaw});
+        backend_->writeSuccessor(auto{obj.keyRaw}, seq, std::move(succ));
+    }
+}
+
+void
+SuccessorExt::updateSuccessorFromCache(uint32_t seq, model::Object const& obj) const
+{
+    auto const lb =
+        cache_.get().getPredecessor(obj.key, seq).value_or(data::LedgerObject{.key = data::kFIRST_KEY, .blob = {}});
+    auto const ub =
+        cache_.get().getSuccessor(obj.key, seq).value_or(data::LedgerObject{.key = data::kLAST_KEY, .blob = {}});
+
+    auto checkBookBase = false;
+    auto const isDeleted = obj.data.empty();
+
+    if (isDeleted) {
+        backend_->writeSuccessor(uint256ToString(lb.key), seq, uint256ToString(ub.key));
+    } else {
+        backend_->writeSuccessor(uint256ToString(lb.key), seq, uint256ToString(obj.key));
+        backend_->writeSuccessor(uint256ToString(obj.key), seq, uint256ToString(ub.key));
+    }
+
+    if (isDeleted) {
+        auto const old = cache_.get().getDeleted(obj.key, seq - 1);
+        ASSERT(old.has_value(), "Deleted object {} must be in cache", ripple::strHex(obj.key));
+
+        checkBookBase = isBookDir(obj.key, *old);
+    } else {
+        checkBookBase = isBookDir(obj.key, obj.data);
+    }
+
+    if (checkBookBase) {
+        auto const current = cache_.get().get(obj.key, seq);
+        auto const bookBase = getBookBase(obj.key);
+
+        if (isDeleted and not current.has_value()) {
+            updateBookSuccessor(cache_.get().getSuccessor(bookBase, seq), seq, bookBase);
+        } else if (current.has_value()) {
+            auto const successor = cache_.get().getSuccessor(bookBase, seq);
+            ASSERT(successor.has_value(), "Book base must have a successor for seq = {}", seq);
+
+            if (successor->key == obj.key) {
+                updateBookSuccessor(successor, seq, bookBase);
+            }
+        }
+    }
+}
+
+void
+SuccessorExt::updateBookSuccessor(
+    std::optional<data::LedgerObject> const& maybeSuccessor,
+    auto seq,
+    ripple::uint256 const& bookBase
+) const
+{
+    if (maybeSuccessor.has_value()) {
+        backend_->writeSuccessor(uint256ToString(bookBase), seq, uint256ToString(maybeSuccessor->key));
+    } else {
+        backend_->writeSuccessor(uint256ToString(bookBase), seq, uint256ToString(data::kLAST_KEY));
+    }
+}
+
+void
+SuccessorExt::writeSuccessors(uint32_t seq) const
+{
+    ripple::uint256 prev = data::kFIRST_KEY;
+    while (auto cur = cache_.get().getSuccessor(prev, seq)) {
+        if (prev == data::kFIRST_KEY)
+            backend_->writeSuccessor(uint256ToString(prev), seq, uint256ToString(cur->key));
+
+        if (isBookDir(cur->key, cur->blob)) {
+            auto base = getBookBase(cur->key);
+
+            // make sure the base is not an actual object
+            if (not cache_.get().get(base, seq)) {
+                auto succ = cache_.get().getSuccessor(base, seq);
+                ASSERT(succ.has_value(), "Book base {} must have a successor", ripple::strHex(base));
+
+                if (succ->key == cur->key)
+                    backend_->writeSuccessor(uint256ToString(base), seq, uint256ToString(cur->key));
+            }
+        }
+
+        prev = cur->key;
+    }
+
+    backend_->writeSuccessor(uint256ToString(prev), seq, uint256ToString(data::kLAST_KEY));
+}
+
+void
+SuccessorExt::writeEdgeKeys(std::uint32_t seq, auto const& edgeKeys) const
+{
+    for (auto const& key : edgeKeys) {
+        auto succ = cache_.get().getSuccessor(*ripple::uint256::fromVoidChecked(key), seq);
+        if (succ)
+            backend_->writeSuccessor(auto{key}, seq, uint256ToString(succ->key));
+    }
+}
+
+}  // namespace etlng::impl

src/etlng/impl/ext/Successor.hpp

@@ -0,0 +1,82 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include "data/BackendInterface.hpp"
+#include "data/LedgerCacheInterface.hpp"
+#include "data/Types.hpp"
+#include "etlng/Models.hpp"
+#include "util/log/Logger.hpp"
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/strHex.h>
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace etlng::impl {
+
+class SuccessorExt {
+    std::shared_ptr<BackendInterface> backend_;
+    std::reference_wrapper<data::LedgerCacheInterface> cache_;
+
+    util::Logger log_{"ETL"};
+
+public:
+    SuccessorExt(std::shared_ptr<BackendInterface> backend, data::LedgerCacheInterface& cache);
+
+    void
+    onInitialData(model::LedgerData const& data) const;
+
+    void
+    onInitialObjects(uint32_t seq, [[maybe_unused]] std::vector<model::Object> const& objs, std::string lastKey) const;
+
+    void
+    onLedgerData(model::LedgerData const& data) const;
+
+private:
+    void
+    writeIncludedSuccessor(uint32_t seq, model::BookSuccessor const& succ) const;
+
+    void
+    writeIncludedSuccessor(uint32_t seq, model::Object const& obj) const;
+
+    void
+    updateSuccessorFromCache(uint32_t seq, model::Object const& obj) const;
+
+    void
+    updateBookSuccessor(
+        std::optional<data::LedgerObject> const& maybeSuccessor,
+        auto seq,
+        ripple::uint256 const& bookBase
+    ) const;
+
+    void
+    writeSuccessors(uint32_t seq) const;
+
+    void
+    writeEdgeKeys(std::uint32_t seq, auto const& edgeKeys) const;
+};
+
+}  // namespace etlng::impl

src/feed/SubscriptionManager.cpp

@@ -191,7 +191,7 @@ SubscriptionManager::unsubBook(ripple::Book const& book, SubscriberSharedPtr con
 void
 SubscriptionManager::pubTransaction(data::TransactionAndMetadata const& txMeta, ripple::LedgerHeader const& lgrInfo)
 {
-    transactionFeed_.pub(txMeta, lgrInfo, backend_);
+    transactionFeed_.pub(txMeta, lgrInfo, backend_, amendmentCenter_);
 }
 
 boost::json::object

src/feed/SubscriptionManager.hpp

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include "data/AmendmentCenterInterface.hpp"
 #include "data/BackendInterface.hpp"
 #include "data/Types.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
@@ -60,6 +61,7 @@ namespace feed {
  */
 class SubscriptionManager : public SubscriptionManagerInterface {
     std::shared_ptr<data::BackendInterface const> backend_;
+    std::shared_ptr<data::AmendmentCenterInterface const> amendmentCenter_;
     util::async::AnyExecutionContext ctx_;
     impl::ForwardFeed manifestFeed_;
     impl::ForwardFeed validationsFeed_;
@@ -74,12 +76,14 @@ public:
      *
      * @param config The configuration to use
      * @param backend The backend to use
+     * @param amendmentCenter The amendmentCenter to use
      * @return A shared pointer to a new instance of SubscriptionManager
      */
     static std::shared_ptr<SubscriptionManager>
     makeSubscriptionManager(
         util::config::ClioConfigDefinition const& config,
-        std::shared_ptr<data::BackendInterface const> const& backend
+        std::shared_ptr<data::BackendInterface const> const& backend,
+        std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter
     )
     {
         auto const workersNum = config.get<uint64_t>("subscription_workers");
@@ -87,7 +91,9 @@ public:
         util::Logger const logger{"Subscriptions"};
         LOG(logger.info()) << "Starting subscription manager with " << workersNum << " workers";
 
-        return std::make_shared<feed::SubscriptionManager>(util::async::PoolExecutionContext(workersNum), backend);
+        return std::make_shared<feed::SubscriptionManager>(
+            util::async::PoolExecutionContext(workersNum), backend, amendmentCenter
+        );
     }
 
     /**
@@ -95,12 +101,15 @@ public:
      *
      * @param executor The executor to use to publish the feeds
      * @param backend The backend to use
+     * @param amendmentCenter The amendmentCenter to use
      */
     SubscriptionManager(
         util::async::AnyExecutionContext&& executor,
-        std::shared_ptr<data::BackendInterface const> const& backend
+        std::shared_ptr<data::BackendInterface const> const& backend,
+        std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter
     )
         : backend_(backend)
+        , amendmentCenter_(amendmentCenter)
         , ctx_(std::move(executor))
         , manifestFeed_(ctx_, "manifest")
         , validationsFeed_(ctx_, "validations")

src/feed/impl/TransactionFeed.cpp

@@ -19,6 +19,7 @@
 
 #include "feed/impl/TransactionFeed.hpp"
 
+#include "data/AmendmentCenterInterface.hpp"
 #include "data/BackendInterface.hpp"
 #include "data/Types.hpp"
 #include "feed/Types.hpp"
@@ -174,7 +175,8 @@ void
 TransactionFeed::pub(
     data::TransactionAndMetadata const& txMeta,
     ripple::LedgerHeader const& lgrInfo,
-    std::shared_ptr<data::BackendInterface const> const& backend
+    std::shared_ptr<data::BackendInterface const> const& backend,
+    std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter
 )
 {
     auto [tx, meta] = rpc::deserializeTxPlusMeta(txMeta, lgrInfo.seq);
@@ -187,7 +189,7 @@ TransactionFeed::pub(
         if (account != amount.issue().account) {
             auto fetchFundsSynchronous = [&]() {
                 data::synchronous([&](boost::asio::yield_context yield) {
-                    ownerFunds = rpc::accountFunds(*backend, lgrInfo.seq, amount, account, yield);
+                    ownerFunds = rpc::accountFunds(*backend, *amendmentCenter, lgrInfo.seq, amount, account, yield);
                 });
             };
             data::retryOnTimeout(fetchFundsSynchronous);

src/feed/impl/TransactionFeed.hpp

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include "data/AmendmentCenterInterface.hpp"
 #include "data/BackendInterface.hpp"
 #include "data/Types.hpp"
 #include "feed/Types.hpp"
@@ -94,6 +95,11 @@ public:
     {
     }
 
+    /**
+     * @brief Move constructor is deleted because TransactionSlot takes TransactionFeed by reference
+     */
+    TransactionFeed(TransactionFeed&&) = delete;
+
     /**
      * @brief Subscribe to the transaction feed.
      * @param subscriber
@@ -180,7 +186,8 @@ public:
     void
     pub(data::TransactionAndMetadata const& txMeta,
         ripple::LedgerHeader const& lgrInfo,
-        std::shared_ptr<data::BackendInterface const> const& backend);
+        std::shared_ptr<data::BackendInterface const> const& backend,
+        std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter);
 
     /**
      * @brief Get the number of subscribers of the transaction feed.

src/main/Main.cpp

@@ -52,7 +52,10 @@ try {
             if (not app::parseConfig(run.configPath))
                 return EXIT_FAILURE;
 
-            util::LogService::init(gClioConfig);
+            if (auto const initSuccess = util::LogService::init(gClioConfig); not initSuccess) {
+                std::cerr << initSuccess.error() << std::endl;
+                return EXIT_FAILURE;
+            }
             app::ClioApplication clio{gClioConfig};
             return clio.run(run.useNgWebServer);
         },
@@ -60,7 +63,10 @@ try {
             if (not app::parseConfig(migrate.configPath))
                 return EXIT_FAILURE;
 
-            util::LogService::init(gClioConfig);
+            if (auto const initSuccess = util::LogService::init(gClioConfig); not initSuccess) {
+                std::cerr << initSuccess.error() << std::endl;
+                return EXIT_FAILURE;
+            }
             app::MigratorApplication migrator{gClioConfig, migrate.subCmd};
             return migrator.run();
         }

src/migration/MigrationApplication.cpp

@@ -41,7 +41,7 @@ MigratorApplication::MigratorApplication(util::config::ClioConfigDefinition cons
 {
     PrometheusService::init(config);
 
-    auto expectedMigrationManager = migration::impl::makeMigrationManager(config);
+    auto expectedMigrationManager = migration::impl::makeMigrationManager(config, cache_);
 
     if (not expectedMigrationManager) {
         throw std::runtime_error("Failed to create migration manager: " + expectedMigrationManager.error());

src/migration/MigrationApplication.hpp

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include "data/LedgerCache.hpp"
 #include "migration/MigrationManagerInterface.hpp"
 #include "util/newconfig/ConfigDefinition.hpp"
 
@@ -76,6 +77,7 @@ class MigratorApplication {
     std::string option_;
     std::shared_ptr<migration::MigrationManagerInterface> migrationManager_;
     MigrateSubCmd cmd_;
+    data::LedgerCache cache_;
 
 public:
     /**

src/migration/cassandra/CassandraMigrationBackend.hpp

@@ -20,9 +20,8 @@
 #pragma once
 
 #include "data/CassandraBackend.hpp"
+#include "data/LedgerCacheInterface.hpp"
 #include "data/cassandra/SettingsProvider.hpp"
-#include "data/cassandra/Types.hpp"
-#include "migration/MigratiorStatus.hpp"
 #include "migration/cassandra/impl/CassandraMigrationSchema.hpp"
 #include "migration/cassandra/impl/Spec.hpp"
 #include "util/log/Logger.hpp"
@@ -49,9 +48,13 @@ public:
      * @brief Construct a new Cassandra Migration Backend object. The backend is not readonly.
      *
      * @param settingsProvider The settings provider
+     * @param cache The ledger cache to use
      */
-    explicit CassandraMigrationBackend(data::cassandra::SettingsProvider settingsProvider)
-        : data::cassandra::CassandraBackend{auto{settingsProvider}, false /* not readonly */}
+    explicit CassandraMigrationBackend(
+        data::cassandra::SettingsProvider settingsProvider,
+        data::LedgerCacheInterface& cache
+    )
+        : data::cassandra::CassandraBackend{auto{settingsProvider}, cache, false /* not readonly */}
         , settingsProvider_(std::move(settingsProvider))
         , migrationSchema_{settingsProvider_}
     {

src/migration/impl/MigrationManagerFactory.cpp

@@ -19,6 +19,7 @@
 
 #include "migration/impl/MigrationManagerFactory.hpp"
 
+#include "data/LedgerCacheInterface.hpp"
 #include "data/cassandra/SettingsProvider.hpp"
 #include "migration/MigrationManagerInterface.hpp"
 #include "migration/cassandra/CassandraMigrationBackend.hpp"
@@ -35,7 +36,7 @@
 namespace migration::impl {
 
 std::expected<std::shared_ptr<MigrationManagerInterface>, std::string>
-makeMigrationManager(util::config::ClioConfigDefinition const& config)
+makeMigrationManager(util::config::ClioConfigDefinition const& config, data::LedgerCacheInterface& cache)
 {
     static util::Logger const log{"Migration"};  // NOLINT(readability-identifier-naming)
     LOG(log.info()) << "Constructing MigrationManager";
@@ -48,11 +49,10 @@ makeMigrationManager(util::config::ClioConfigDefinition const& config)
     }
 
     auto const cfg = config.getObject("database." + type);
-
     auto migrationCfg = config.getObject("migration");
 
     return std::make_shared<cassandra::CassandraMigrationManager>(
-        std::make_shared<cassandra::CassandraMigrationBackend>(data::cassandra::SettingsProvider{cfg}),
+        std::make_shared<cassandra::CassandraMigrationBackend>(data::cassandra::SettingsProvider{cfg}, cache),
         std::move(migrationCfg)
     );
 }

src/migration/impl/MigrationManagerFactory.hpp

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include "data/LedgerCacheInterface.hpp"
 #include "migration/MigrationManagerInterface.hpp"
 #include "util/newconfig/ConfigDefinition.hpp"
 
@@ -33,9 +34,10 @@ namespace migration::impl {
  *
  * @param config The configuration of the migration application, it contains the database connection configuration and
  * other migration specific configurations
+ * @param cache The ledger cache to use
  * @return A shared pointer to the MigrationManagerInterface if the creation was successful, otherwise an error message
  */
 std::expected<std::shared_ptr<MigrationManagerInterface>, std::string>
-makeMigrationManager(util::config::ClioConfigDefinition const& config);
+makeMigrationManager(util::config::ClioConfigDefinition const& config, data::LedgerCacheInterface& cache);
 
 }  // namespace migration::impl

src/rpc/AMMHelpers.cpp

@@ -19,6 +19,7 @@
 
 #include "rpc/AMMHelpers.hpp"
 
+#include "data/AmendmentCenterInterface.hpp"
 #include "data/BackendInterface.hpp"
 #include "rpc/RPCHelpers.hpp"
 
@@ -38,6 +39,7 @@ namespace rpc {
 std::pair<ripple::STAmount, ripple::STAmount>
 getAmmPoolHolds(
     BackendInterface const& backend,
+    data::AmendmentCenterInterface const& amendmentCenter,
     std::uint32_t sequence,
     ripple::AccountID const& ammAccountID,
     ripple::Issue const& issue1,
@@ -46,10 +48,12 @@ getAmmPoolHolds(
     boost::asio::yield_context yield
 )
 {
-    auto const assetInBalance =
-        accountHolds(backend, sequence, ammAccountID, issue1.currency, issue1.account, freezeHandling, yield);
-    auto const assetOutBalance =
-        accountHolds(backend, sequence, ammAccountID, issue2.currency, issue2.account, freezeHandling, yield);
+    auto const assetInBalance = accountHolds(
+        backend, amendmentCenter, sequence, ammAccountID, issue1.currency, issue1.account, freezeHandling, yield
+    );
+    auto const assetOutBalance = accountHolds(
+        backend, amendmentCenter, sequence, ammAccountID, issue2.currency, issue2.account, freezeHandling, yield
+    );
     return std::make_pair(assetInBalance, assetOutBalance);
 }
 
@@ -65,7 +69,9 @@ getAmmLpHolds(
 )
 {
     auto const lptCurrency = ammLPTCurrency(cur1, cur2);
-    return accountHolds(backend, sequence, lpAccount, lptCurrency, ammAccount, true, yield);
+
+    // not using accountHolds because we don't need to check if the associated tokens of the LP are frozen
+    return ammAccountHolds(backend, sequence, lpAccount, lptCurrency, ammAccount, true, yield);
 }
 
 ripple::STAmount

src/rpc/AMMHelpers.hpp

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include "data/AmendmentCenterInterface.hpp"
 #include "data/BackendInterface.hpp"
 
 #include <boost/asio/spawn.hpp>
@@ -37,6 +38,7 @@ namespace rpc {
  * @brief getAmmPoolHolds returns the balances of the amm asset pair
  *
  * @param backend The backend to use
+ * @param amendmentCenter The amendmentCenter to use
  * @param sequence The sequence number to use
  * @param ammAccountID The amm account
  * @param issue1 The first issue
@@ -48,6 +50,7 @@ namespace rpc {
 std::pair<ripple::STAmount, ripple::STAmount>
 getAmmPoolHolds(
     BackendInterface const& backend,
+    data::AmendmentCenterInterface const& amendmentCenter,
     std::uint32_t sequence,
     ripple::AccountID const& ammAccountID,
     ripple::Issue const& issue1,

src/rpc/CMakeLists.txt

@@ -1,3 +1,8 @@
+# Have to use RPCCenter as a separate library since it is used in util
+add_library(clio_rpc_center)
+target_sources(clio_rpc_center PRIVATE RPCCenter.cpp)
+target_include_directories(clio_rpc_center PUBLIC "${CMAKE_SOURCE_DIR}/src")
+
 add_library(clio_rpc)
 
 target_sources(

src/rpc/RPCCenter.cpp

@@ -0,0 +1,112 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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 "rpc/RPCCenter.hpp"
+
+#include <string_view>
+#include <unordered_set>
+
+namespace rpc {
+
+namespace {
+
+std::unordered_set<std::string_view> const&
+handledRpcs()
+{
+    static std::unordered_set<std::string_view> kHANDLED_RPCS = {
+        "account_channels",
+        "account_currencies",
+        "account_info",
+        "account_lines",
+        "account_nfts",
+        "account_objects",
+        "account_offers",
+        "account_tx",
+        "amm_info",
+        "book_changes",
+        "book_offers",
+        "deposit_authorized",
+        "feature",
+        "gateway_balances",
+        "get_aggregate_price",
+        "ledger",
+        "ledger_data",
+        "ledger_entry",
+        "ledger_index",
+        "ledger_range",
+        "mpt_holders",
+        "nfts_by_issuer",
+        "nft_history",
+        "nft_buy_offers",
+        "nft_info",
+        "nft_sell_offers",
+        "noripple_check",
+        "ping",
+        "random",
+        "server_info",
+        "transaction_entry",
+        "tx",
+        "subscribe",
+        "unsubscribe",
+        "version",
+    };
+    return kHANDLED_RPCS;
+}
+
+std::unordered_set<std::string_view> const&
+forwardedRpcs()
+{
+    static std::unordered_set<std::string_view> const kFORWARDED_RPCS = {
+        "server_definitions",
+        "server_state",
+        "submit",
+        "submit_multisigned",
+        "fee",
+        "ledger_closed",
+        "ledger_current",
+        "ripple_path_find",
+        "manifest",
+        "channel_authorize",
+        "channel_verify",
+        "simulate",
+    };
+    return kFORWARDED_RPCS;
+}
+
+}  // namespace
+
+bool
+RPCCenter::isRpcName(std::string_view s)
+{
+    return isHandled(s) || isForwarded(s);
+}
+
+bool
+RPCCenter::isHandled(std::string_view s)
+{
+    return handledRpcs().contains(s);
+}
+
+bool
+RPCCenter::isForwarded(std::string_view s)
+{
+    return forwardedRpcs().contains(s);
+}
+
+}  // namespace rpc

src/rpc/RPCCenter.hpp

@@ -0,0 +1,61 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2025, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    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.
+*/
+//==============================================================================
+
+#pragma once
+
+#include <string_view>
+
+namespace rpc {
+
+/**
+ * @brief Registry of RPC commands supported by Clio
+ *
+ * The RPCCenter maintains lists of RPC commands that can be handled locally
+ * and those that need to be forwarded to rippled.
+ */
+struct RPCCenter {
+    /**
+     * @brief Checks if a string is a valid RPC command name
+     *
+     * @param s The string to check
+     * @return true if the string is a recognized RPC name, false otherwise
+     */
+    static bool
+    isRpcName(std::string_view s);
+
+    /**
+     * @brief Checks if a string is a RPC command handled by Clio without forwarding to rippled
+     *
+     * @param s The string to check
+     * @return true if the string is a handled RPC command, false otherwise
+     */
+    static bool
+    isHandled(std::string_view s);
+
+    /**
+     * @brief Checks if a string is a RPC command that will be forwarded to rippled
+     *
+     * @param s The string to check
+     * @return true if the string is a forwarded RPC command, false otherwise
+     */
+    static bool
+    isForwarded(std::string_view s);
+};
+
+}  // namespace rpc

src/rpc/RPCEngine.hpp

@@ -20,6 +20,7 @@
 #pragma once
 
 #include "data/BackendInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "rpc/Errors.hpp"
 #include "rpc/RPCHelpers.hpp"
 #include "rpc/WorkQueue.hpp"
@@ -55,7 +56,7 @@ namespace rpc {
 /**
  * @brief The RPC engine that ties all RPC-related functionality together.
  */
-template <typename LoadBalancerType, typename CountersType>
+template <typename CountersType>
 class RPCEngine {
     util::Logger perfLog_{"Performance"};
     util::Logger log_{"RPC"};
@@ -67,7 +68,7 @@ class RPCEngine {
 
     std::shared_ptr<HandlerProvider const> handlerProvider_;
 
-    impl::ForwardingProxy<LoadBalancerType, CountersType, HandlerProvider> forwardingProxy_;
+    impl::ForwardingProxy<CountersType, HandlerProvider> forwardingProxy_;
 
     std::optional<util::ResponseExpirationCache> responseCache_;
 
@@ -86,7 +87,7 @@ public:
     RPCEngine(
         util::config::ClioConfigDefinition const& config,
         std::shared_ptr<BackendInterface> const& backend,
-        std::shared_ptr<LoadBalancerType> const& balancer,
+        std::shared_ptr<etlng::LoadBalancerInterface> const& balancer,
         web::dosguard::DOSGuardInterface const& dosGuard,
         WorkQueue& workQueue,
         CountersType& counters,
@@ -128,7 +129,7 @@ public:
     makeRPCEngine(
         util::config::ClioConfigDefinition const& config,
         std::shared_ptr<BackendInterface> const& backend,
-        std::shared_ptr<LoadBalancerType> const& balancer,
+        std::shared_ptr<etlng::LoadBalancerInterface> const& balancer,
         web::dosguard::DOSGuardInterface const& dosGuard,
         WorkQueue& workQueue,
         CountersType& counters,

src/rpc/RPCHelpers.cpp

@@ -19,12 +19,15 @@
 
 #include "rpc/RPCHelpers.hpp"
 
+#include "data/AmendmentCenter.hpp"
+#include "data/AmendmentCenterInterface.hpp"
 #include "data/BackendInterface.hpp"
 #include "data/Types.hpp"
 #include "rpc/Errors.hpp"
 #include "rpc/JS.hpp"
 #include "rpc/common/Types.hpp"
 #include "util/AccountUtils.hpp"
+#include "util/Assert.hpp"
 #include "util/Profiler.hpp"
 #include "util/log/Logger.hpp"
 #include "web/Context.hpp"
@@ -382,7 +385,7 @@ insertDeliverMaxAlias(boost::json::object& txJson, std::uint32_t const apiVersio
 {
     if (txJson.contains(JS(TransactionType)) and txJson.at(JS(TransactionType)).is_string() and
         txJson.at(JS(TransactionType)).as_string() == JS(Payment) and txJson.contains(JS(Amount))) {
-        txJson[JS(DeliverMax)] = txJson[JS(Amount)];
+        txJson.insert_or_assign(JS(DeliverMax), txJson[JS(Amount)]);
         if (apiVersion > 1)
             txJson.erase(JS(Amount));
     }
@@ -899,6 +902,26 @@ isGlobalFrozen(
     return sle.isFlag(ripple::lsfGlobalFreeze);
 }
 
+bool
+fetchAndCheckAnyFlagsExists(
+    BackendInterface const& backend,
+    std::uint32_t sequence,
+    ripple::Keylet const& keylet,
+    std::vector<std::uint32_t> const& flags,
+    boost::asio::yield_context yield
+)
+{
+    auto const blob = backend.fetchLedgerObject(keylet.key, sequence, yield);
+
+    if (!blob)
+        return false;
+
+    ripple::SerialIter it{blob->data(), blob->size()};
+    ripple::SLE const sle{it, keylet.key};
+
+    return std::ranges::any_of(flags, [sle](std::uint32_t flag) { return sle.isFlag(flag); });
+}
+
 bool
 isFrozen(
     BackendInterface const& backend,
@@ -912,35 +935,57 @@ isFrozen(
     if (ripple::isXRP(currency))
         return false;
 
-    auto key = ripple::keylet::account(issuer).key;
-    auto blob = backend.fetchLedgerObject(key, sequence, yield);
-
-    if (!blob)
-        return false;
-
-    ripple::SerialIter it{blob->data(), blob->size()};
-    ripple::SLE const sle{it, key};
-
-    if (sle.isFlag(ripple::lsfGlobalFreeze))
+    if (fetchAndCheckAnyFlagsExists(
+            backend, sequence, ripple::keylet::account(issuer), {ripple::lsfGlobalFreeze}, yield
+        ))
         return true;
 
-    if (issuer != account) {
-        key = ripple::keylet::line(account, issuer, currency).key;
-        blob = backend.fetchLedgerObject(key, sequence, yield);
+    auto const trustLineKeylet = ripple::keylet::line(account, issuer, currency);
+    return issuer != account &&
+        fetchAndCheckAnyFlagsExists(
+               backend,
+               sequence,
+               trustLineKeylet,
+               {(issuer > account) ? ripple::lsfHighFreeze : ripple::lsfLowFreeze},
+               yield
+        );
+}
 
-        if (!blob)
-            return false;
+bool
+isDeepFrozen(
+    BackendInterface const& backend,
+    std::uint32_t sequence,
+    ripple::AccountID const& account,
+    ripple::Currency const& currency,
+    ripple::AccountID const& issuer,
+    boost::asio::yield_context yield
+)
+{
+    if (ripple::isXRP(currency))
+        return false;
 
-        ripple::SerialIter issuerIt{blob->data(), blob->size()};
-        ripple::SLE const issuerLine{issuerIt, key};
+    if (issuer == account)
+        return false;
 
-        auto frozen = (issuer > account) ? ripple::lsfHighFreeze : ripple::lsfLowFreeze;
+    auto const trustLineKeylet = ripple::keylet::line(account, issuer, currency);
 
-        if (issuerLine.isFlag(frozen))
-            return true;
-    }
+    return fetchAndCheckAnyFlagsExists(
+        backend, sequence, trustLineKeylet, {ripple::lsfHighDeepFreeze, ripple::lsfLowDeepFreeze}, yield
+    );
+}
 
-    return false;
+bool
+isLPTokenFrozen(
+    BackendInterface const& backend,
+    std::uint32_t sequence,
+    ripple::AccountID const& account,
+    ripple::Issue const& asset,
+    ripple::Issue const& asset2,
+    boost::asio::yield_context yield
+)
+{
+    return isFrozen(backend, sequence, account, asset.currency, asset.account, yield) ||
+        isFrozen(backend, sequence, account, asset2.currency, asset2.account, yield);
 }
 
 ripple::XRPAmount
@@ -981,6 +1026,7 @@ xrpLiquid(
 ripple::STAmount
 accountFunds(
     BackendInterface const& backend,
+    data::AmendmentCenterInterface const& amendmentCenter,
     std::uint32_t const sequence,
     ripple::STAmount const& amount,
     ripple::AccountID const& id,
@@ -991,12 +1037,58 @@ accountFunds(
         return amount;
     }
 
-    return accountHolds(backend, sequence, id, amount.getCurrency(), amount.getIssuer(), true, yield);
+    return accountHolds(backend, amendmentCenter, sequence, id, amount.getCurrency(), amount.getIssuer(), true, yield);
+}
+
+ripple::STAmount
+ammAccountHolds(
+    BackendInterface const& backend,
+    std::uint32_t sequence,
+    ripple::AccountID const& account,
+    ripple::Currency const& currency,
+    ripple::AccountID const& issuer,
+    bool const zeroIfFrozen,
+    boost::asio::yield_context yield
+)
+{
+    ripple::STAmount amount;
+    ASSERT(!ripple::isXRP(currency), "LPToken currency can never be XRP");
+    if (ripple::isXRP(currency))
+        return {xrpLiquid(backend, sequence, account, yield)};
+
+    auto const key = ripple::keylet::line(account, issuer, currency).key;
+    auto const blob = backend.fetchLedgerObject(key, sequence, yield);
+
+    if (!blob) {
+        amount.setIssue(ripple::Issue(currency, issuer));
+        amount.clear();
+        return amount;
+    }
+
+    ripple::SerialIter it{blob->data(), blob->size()};
+    ripple::SLE const sle{it, key};
+
+    if (zeroIfFrozen &&
+        (isFrozen(backend, sequence, account, currency, issuer, yield) ||
+         isDeepFrozen(backend, sequence, account, currency, issuer, yield))) {
+        amount.setIssue(ripple::Issue(currency, issuer));
+        amount.clear();
+    } else {
+        amount = sle.getFieldAmount(ripple::sfBalance);
+        if (account > issuer) {
+            // Put balance in account terms.
+            amount.negate();
+        }
+        amount.setIssuer(issuer);
+    }
+
+    return amount;
 }
 
 ripple::STAmount
 accountHolds(
     BackendInterface const& backend,
+    data::AmendmentCenterInterface const& amendmentCenter,
     std::uint32_t sequence,
     ripple::AccountID const& account,
     ripple::Currency const& currency,
@@ -1018,19 +1110,61 @@ accountHolds(
         return amount;
     }
 
-    ripple::SerialIter it{blob->data(), blob->size()};
-    ripple::SLE const sle{it, key};
+    auto const allowBalance = [&]() {
+        if (!zeroIfFrozen)
+            return true;
+
+        if (isFrozen(backend, sequence, account, currency, issuer, yield))
+            return false;
+
+        if (amendmentCenter.isEnabled(yield, data::Amendments::fixFrozenLPTokenTransfer, sequence)) {
+            auto const issuerBlob = backend.fetchLedgerObject(ripple::keylet::account(issuer).key, sequence, yield);
+
+            if (!issuerBlob)
+                return false;
+
+            ripple::SLE const issuerSle{
+                ripple::SerialIter{issuerBlob->data(), issuerBlob->size()}, ripple::keylet::account(issuer).key
+            };
+
+            // if the issuer is an amm account, then currency is lptoken, so we will need to check if the
+            // assets in the pool are frozen as well
+            if (issuerSle.isFieldPresent(ripple::sfAMMID)) {
+                auto const ammKeylet = ripple::keylet::amm(issuerSle[ripple::sfAMMID]);
+                auto const ammBlob = backend.fetchLedgerObject(ammKeylet.key, sequence, yield);
+
+                if (!ammBlob)
+                    return false;
+
+                ripple::SLE const ammSle{ripple::SerialIter{ammBlob->data(), ammBlob->size()}, ammKeylet.key};
+
+                return !isLPTokenFrozen(
+                    backend,
+                    sequence,
+                    account,
+                    ammSle[ripple::sfAsset].get<ripple::Issue>(),
+                    ammSle[ripple::sfAsset2].get<ripple::Issue>(),
+                    yield
+                );
+            }
+        }
+
+        return true;
+    }();
+
+    if (allowBalance) {
+        ripple::SerialIter it{blob->data(), blob->size()};
+        ripple::SLE const sle{it, key};
 
-    if (zeroIfFrozen && isFrozen(backend, sequence, account, currency, issuer, yield)) {
-        amount.setIssue(ripple::Issue(currency, issuer));
-        amount.clear();
-    } else {
         amount = sle.getFieldAmount(ripple::sfBalance);
         if (account > issuer) {
             // Put balance in account terms.
             amount.negate();
         }
         amount.setIssuer(issuer);
+    } else {
+        amount.setIssue(ripple::Issue(currency, issuer));
+        amount.clear();
     }
 
     return amount;
@@ -1064,6 +1198,7 @@ postProcessOrderBook(
     ripple::Book const& book,
     ripple::AccountID const& takerID,
     data::BackendInterface const& backend,
+    data::AmendmentCenterInterface const& amendmentCenter,
     std::uint32_t const ledgerSequence,
     boost::asio::yield_context yield
 )
@@ -1106,7 +1241,14 @@ postProcessOrderBook(
                     firstOwnerOffer = false;
                 } else {
                     saOwnerFunds = accountHolds(
-                        backend, ledgerSequence, uOfferOwnerID, book.out.currency, book.out.account, true, yield
+                        backend,
+                        amendmentCenter,
+                        ledgerSequence,
+                        uOfferOwnerID,
+                        book.out.currency,
+                        book.out.account,
+                        true,
+                        yield
                     );
 
                     if (saOwnerFunds < beast::zero)

src/rpc/RPCHelpers.hpp

@@ -24,11 +24,13 @@
  * This file contains a variety of utility functions used when executing the handlers.
  */
 
+#include "data/AmendmentCenterInterface.hpp"
 #include "data/BackendInterface.hpp"
 #include "data/Types.hpp"
 #include "rpc/Errors.hpp"
 #include "rpc/common/Types.hpp"
 #include "util/JsonUtils.hpp"
+#include "util/Taggable.hpp"
 #include "util/log/Logger.hpp"
 #include "web/Context.hpp"
 
@@ -427,10 +429,75 @@ isFrozen(
     boost::asio::yield_context yield
 );
 
+/**
+ * @brief Fetches a ledger object and checks if any of the specified flag is set on the account.
+ *
+ * @param backend The backend to use
+ * @param sequence The sequence
+ * @param keylet The keylet representing the object
+ * @param flags The flags to check on the fetched `SLE`.
+ * @param yield The coroutine context
+ * @return true if any of the flag in flags are set for this account; false otherwise
+ */
+bool
+fetchAndCheckAnyFlagsExists(
+    BackendInterface const& backend,
+    std::uint32_t sequence,
+    ripple::Keylet const& keylet,
+    std::vector<std::uint32_t> const& flags,
+    boost::asio::yield_context yield
+);
+
+/**
+ * @brief Whether the trustline is deep frozen.
+ *
+ * For deep freeze, (unlike regular freeze) we do not care which account has the high/low deep freeze flag.
+ * We only care about if the trustline is deep frozen or not.
+ *
+ * @param backend The backend to use
+ * @param sequence The sequence
+ * @param account The account
+ * @param currency The currency
+ * @param issuer The issuer
+ * @param yield The coroutine context
+ * @return true if the account is deep frozen; false otherwise
+ */
+bool
+isDeepFrozen(
+    BackendInterface const& backend,
+    std::uint32_t sequence,
+    ripple::AccountID const& account,
+    ripple::Currency const& currency,
+    ripple::AccountID const& issuer,
+    boost::asio::yield_context yield
+);
+
+/**
+ * @brief Whether the account that owns a LPToken is frozen for the assets in the pool
+ *
+ * @param backend The backend to use
+ * @param sequence The sequence
+ * @param account The account
+ * @param asset The first asset in the pool
+ * @param asset2 The second asset in the pool
+ * @param yield The coroutine context
+ * @return true if account is frozen for one of the assets
+ */
+bool
+isLPTokenFrozen(
+    BackendInterface const& backend,
+    std::uint32_t sequence,
+    ripple::AccountID const& account,
+    ripple::Issue const& asset,
+    ripple::Issue const& asset2,
+    boost::asio::yield_context yield
+);
+
 /**
  * @brief Get the account funds
  *
  * @param backend The backend to use
+ * @param amendmentCenter The amendmentCenter to use
  * @param sequence The sequence
  * @param amount The amount
  * @param id The account ID
@@ -440,6 +507,7 @@ isFrozen(
 ripple::STAmount
 accountFunds(
     BackendInterface const& backend,
+    data::AmendmentCenterInterface const& amendmentCenter,
     std::uint32_t sequence,
     ripple::STAmount const& amount,
     ripple::AccountID const& id,
@@ -450,6 +518,7 @@ accountFunds(
  * @brief Get the amount that an account holds
  *
  * @param backend The backend to use
+ * @param amendmentCenter The amendmentCenter to use
  * @param sequence The sequence
  * @param account The account
  * @param currency The currency
@@ -461,6 +530,7 @@ accountFunds(
 ripple::STAmount
 accountHolds(
     BackendInterface const& backend,
+    data::AmendmentCenterInterface const& amendmentCenter,
     std::uint32_t sequence,
     ripple::AccountID const& account,
     ripple::Currency const& currency,
@@ -469,6 +539,29 @@ accountHolds(
     boost::asio::yield_context yield
 );
 
+/**
+ * @brief Get the amount that an LPToken owner holds
+ *
+ * @param backend The backend to use
+ * @param sequence The sequence
+ * @param account The account
+ * @param currency The currency
+ * @param issuer The issuer
+ * @param zeroIfFrozen Whether to return zero if frozen
+ * @param yield The coroutine context
+ * @return The amount account holds
+ */
+ripple::STAmount
+ammAccountHolds(
+    BackendInterface const& backend,
+    std::uint32_t sequence,
+    ripple::AccountID const& account,
+    ripple::Currency const& currency,
+    ripple::AccountID const& issuer,
+    bool const zeroIfFrozen,
+    boost::asio::yield_context yield
+);
+
 /**
  * @brief Get the transfer rate
  *
@@ -510,6 +603,7 @@ xrpLiquid(
  * @param book The book
  * @param takerID The taker ID
  * @param backend The backend to use
+ * @param amendmentCenter The amendmentCenter to use
  * @param ledgerSequence The ledger sequence
  * @param yield The coroutine context
  * @return The post processed order book
@@ -520,6 +614,7 @@ postProcessOrderBook(
     ripple::Book const& book,
     ripple::AccountID const& takerID,
     data::BackendInterface const& backend,
+    data::AmendmentCenterInterface const& amendmentCenter,
     std::uint32_t ledgerSequence,
     boost::asio::yield_context yield
 );
@@ -650,12 +745,13 @@ decodeCTID(T const ctid) noexcept
  * @brief Log the duration of the request processing
  *
  * @tparam T The type of the duration
- * @param ctx The context of the request
+ * @param request The request to log
+ * @param tag The tag of the context of the request
  * @param dur The duration to log
  */
-template <typename T>
+template <typename DurationType>
 void
-logDuration(web::Context const& ctx, T const& dur)
+logDuration(boost::json::object const& request, util::BaseTagDecorator const& tag, DurationType const& dur)
 {
     using boost::json::serialize;
 
@@ -665,15 +761,15 @@ logDuration(web::Context const& ctx, T const& dur)
     auto const millis = std::chrono::duration_cast<std::chrono::milliseconds>(dur).count();
     auto const seconds = std::chrono::duration_cast<std::chrono::seconds>(dur).count();
     auto const msg = fmt::format(
-        "Request processing duration = {} milliseconds. request = {}", millis, serialize(util::removeSecret(ctx.params))
+        "Request processing duration = {} milliseconds. request = {}", millis, serialize(util::removeSecret(request))
     );
 
     if (seconds > kDURATION_ERROR_THRESHOLD_SECONDS) {
-        LOG(log.error()) << ctx.tag() << msg;
+        LOG(log.error()) << tag << msg;
     } else if (seconds > 1) {
-        LOG(log.warn()) << ctx.tag() << msg;
+        LOG(log.warn()) << tag << msg;
     } else
-        LOG(log.info()) << ctx.tag() << msg;
+        LOG(log.info()) << tag << msg;
 }
 
 /**

src/rpc/common/impl/ForwardingProxy.hpp

@@ -19,7 +19,9 @@
 
 #pragma once
 
+#include "etlng/LoadBalancerInterface.hpp"
 #include "rpc/Errors.hpp"
+#include "rpc/RPCCenter.hpp"
 #include "rpc/RPCHelpers.hpp"
 #include "rpc/common/Types.hpp"
 #include "util/log/Logger.hpp"
@@ -31,20 +33,21 @@
 #include <memory>
 #include <string>
 #include <unordered_set>
+#include <utility>
 
 namespace rpc::impl {
 
-template <typename LoadBalancerType, typename CountersType, typename HandlerProviderType>
+template <typename CountersType, typename HandlerProviderType>
 class ForwardingProxy {
     util::Logger log_{"RPC"};
 
-    std::shared_ptr<LoadBalancerType> balancer_;
+    std::shared_ptr<etlng::LoadBalancerInterface> balancer_;
     std::reference_wrapper<CountersType> counters_;
     std::shared_ptr<HandlerProviderType const> handlerProvider_;
 
 public:
     ForwardingProxy(
-        std::shared_ptr<LoadBalancerType> const& balancer,
+        std::shared_ptr<etlng::LoadBalancerInterface> const& balancer,
         CountersType& counters,
         std::shared_ptr<HandlerProviderType const> const& handlerProvider
     )
@@ -104,21 +107,7 @@ public:
     bool
     isProxied(std::string const& method) const
     {
-        static std::unordered_set<std::string> const kPROXIED_COMMANDS{
-            "server_definitions",
-            "server_state",
-            "submit",
-            "submit_multisigned",
-            "fee",
-            "ledger_closed",
-            "ledger_current",
-            "ripple_path_find",
-            "manifest",
-            "channel_authorize",
-            "channel_verify",
-        };
-
-        return kPROXIED_COMMANDS.contains(method);
+        return RPCCenter::isForwarded(method);
     }
 
 private:

src/rpc/common/impl/HandlerProvider.cpp

@@ -21,7 +21,8 @@
 
 #include "data/AmendmentCenterInterface.hpp"
 #include "data/BackendInterface.hpp"
-#include "etl/ETLService.hpp"
+#include "etlng/ETLServiceInterface.hpp"
+#include "etlng/LoadBalancerInterface.hpp"
 #include "feed/SubscriptionManagerInterface.hpp"
 #include "rpc/Counters.hpp"
 #include "rpc/common/AnyHandler.hpp"
@@ -65,6 +66,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <unordered_set>
 
 namespace rpc::impl {
 
@@ -72,8 +74,8 @@ ProductionHandlerProvider::ProductionHandlerProvider(
     util::config::ClioConfigDefinition const& config,
     std::shared_ptr<BackendInterface> const& backend,
     std::shared_ptr<feed::SubscriptionManagerInterface> const& subscriptionManager,
-    std::shared_ptr<etl::LoadBalancer> const& balancer,
-    std::shared_ptr<etl::ETLService const> const& etl,
+    std::shared_ptr<etlng::LoadBalancerInterface> const& balancer,
+    std::shared_ptr<etlng::ETLServiceInterface const> const& etl,
     std::shared_ptr<data::AmendmentCenterInterface const> const& amendmentCenter,
     Counters const& counters
 )
@@ -86,14 +88,14 @@ ProductionHandlerProvider::ProductionHandlerProvider(
           {"account_objects", {.handler = AccountObjectsHandler{backend}}},
           {"account_offers", {.handler = AccountOffersHandler{backend}}},
           {"account_tx", {.handler = AccountTxHandler{backend}}},
-          {"amm_info", {.handler = AMMInfoHandler{backend}}},
+          {"amm_info", {.handler = AMMInfoHandler{backend, amendmentCenter}}},
           {"book_changes", {.handler = BookChangesHandler{backend}}},
-          {"book_offers", {.handler = BookOffersHandler{backend}}},
+          {"book_offers", {.handler = BookOffersHandler{backend, amendmentCenter}}},
           {"deposit_authorized", {.handler = DepositAuthorizedHandler{backend}}},
           {"feature", {.handler = FeatureHandler{backend, amendmentCenter}}},
           {"gateway_balances", {.handler = GatewayBalancesHandler{backend}}},
           {"get_aggregate_price", {.handler = GetAggregatePriceHandler{backend}}},
-          {"ledger", {.handler = LedgerHandler{backend}}},
+          {"ledger", {.handler = LedgerHandler{backend, amendmentCenter}}},
           {"ledger_data", {.handler = LedgerDataHandler{backend}}},
           {"ledger_entry", {.handler = LedgerEntryHandler{backend}}},
           {"ledger_index", {.handler = LedgerIndexHandler{backend}, .isClioOnly = true}},  // clio only
@@ -110,7 +112,7 @@ ProductionHandlerProvider::ProductionHandlerProvider(
           {"server_info", {.handler = ServerInfoHandler{backend, subscriptionManager, balancer, etl, counters}}},
           {"transaction_entry", {.handler = TransactionEntryHandler{backend}}},
           {"tx", {.handler = TxHandler{backend, etl}}},
-          {"subscribe", {.handler = SubscribeHandler{backend, subscriptionManager}}},
+          {"subscribe", {.handler = SubscribeHandler{backend, amendmentCenter, subscriptionManager}}},
           {"unsubscribe", {.handler = UnsubscribeHandler{subscriptionManager}}},
           {"version", {.handler = VersionHandler{config}}},
       }
@@ -138,4 +140,13 @@ ProductionHandlerProvider::isClioOnly(std::string const& command) const
     return handlerMap_.contains(command) && handlerMap_.at(command).isClioOnly;
 }
 
+std::unordered_set<std::string>
+ProductionHandlerProvider::handlerNames() const
+{
+    std::unordered_set<std::string> result;
+    for (auto const& [name, handler] : handlerMap_)
+        result.insert(name);
+    return result;
+}
+
 }  // namespace rpc::impl