Update SQLite3 max_page_count to match current defaults (#5114)

When rippled initiates a connection to SQLite3, rippled sends a "PRAGMA"
statement defining the maximum number of pages allowed in the database.
Update the max_page_count so it is consistent with the default for newer
versions of SQLite3. Increasing max_page_count is critical for keeping
full history servers online.

Fix #5102

.git-blame-ignore-revs

@@ -2,3 +2,7 @@
 # To use it by default in git blame:
 # git config blame.ignoreRevsFile .git-blame-ignore-revs
 50760c693510894ca368e90369b0cc2dabfd07f3
+e2384885f5f630c8f0ffe4bf21a169b433a16858
+241b9ddde9e11beb7480600fd5ed90e1ef109b21
+760f16f56835663d9286bd29294d074de26a7ba6
+0eebe6a5f4246fced516d52b83ec4e7f47373edd

.github/actions/xahau-configure-ccache/action.yml

@@ -0,0 +1,31 @@
+name: 'Configure ccache'
+description: 'Sets up ccache with consistent configuration'
+
+inputs:
+  max_size:
+    description: 'Maximum cache size'
+    required: false
+    default: '2G'
+  hash_dir:
+    description: 'Whether to include directory paths in hash'
+    required: false
+    default: 'true'
+  compiler_check:
+    description: 'How to check compiler for changes'
+    required: false
+    default: 'content'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Configure ccache
+      shell: bash
+      run: |
+        mkdir -p ~/.ccache
+        export CONF_PATH="${CCACHE_CONFIGPATH:-${CCACHE_DIR:-$HOME/.ccache}/ccache.conf}"
+        mkdir -p $(dirname "$CONF_PATH")
+        echo "max_size = ${{ inputs.max_size }}" > "$CONF_PATH"
+        echo "hash_dir = ${{ inputs.hash_dir }}" >> "$CONF_PATH"
+        echo "compiler_check = ${{ inputs.compiler_check }}" >> "$CONF_PATH"
+        ccache -p # Print config for verification
+        ccache -z # Zero statistics before the build

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

@@ -0,0 +1,108 @@
+name: build
+description: 'Builds the project with ccache integration'
+
+inputs:
+  generator:
+    description: 'CMake generator to use'
+    required: true
+  configuration:
+    description: 'Build configuration (Debug, Release, etc.)'
+    required: true
+  build_dir:
+    description: 'Directory to build in'
+    required: false
+    default: '.build'
+  cc:
+    description: 'C compiler to use'
+    required: false
+    default: ''
+  cxx:
+    description: 'C++ compiler to use'
+    required: false
+    default: ''
+  compiler-id:
+    description: 'Unique identifier for compiler/version combination used for cache keys'
+    required: false
+    default: ''
+  cache_version:
+    description: 'Cache version for invalidation'
+    required: false
+    default: '1'
+  ccache_enabled:
+    description: 'Whether to use ccache'
+    required: false
+    default: 'true'
+  main_branch:
+    description: 'Main branch name for restore keys'
+    required: false
+    default: 'dev'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Generate safe branch name
+      if: inputs.ccache_enabled == 'true'
+      id: safe-branch
+      shell: bash
+      run: |
+        SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr -c 'a-zA-Z0-9_.-' '-')
+        echo "name=${SAFE_BRANCH}" >> $GITHUB_OUTPUT
+
+    - name: Restore ccache directory
+      if: inputs.ccache_enabled == 'true'
+      id: ccache-restore
+      uses: actions/cache/restore@v4
+      with:
+        path: ~/.ccache
+        key: ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ steps.safe-branch.outputs.name }}
+        restore-keys: |
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ inputs.main_branch }}
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-
+
+    - name: Configure project
+      shell: bash
+      run: |
+        mkdir -p ${{ inputs.build_dir }}
+        cd ${{ inputs.build_dir }}
+        
+        # Set compiler environment variables if provided
+        if [ -n "${{ inputs.cc }}" ]; then
+          export CC="${{ inputs.cc }}"
+        fi
+        
+        if [ -n "${{ inputs.cxx }}" ]; then
+          export CXX="${{ inputs.cxx }}"
+        fi
+        
+        # Configure ccache launcher args
+        CCACHE_ARGS=""
+        if [ "${{ inputs.ccache_enabled }}" = "true" ]; then
+          CCACHE_ARGS="-DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache"
+        fi
+        
+        # Run CMake configure
+        cmake .. \
+          -G "${{ inputs.generator }}" \
+          $CCACHE_ARGS \
+          -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+          -DCMAKE_BUILD_TYPE=${{ inputs.configuration }}
+
+    - name: Build project
+      shell: bash
+      run: |
+        cd ${{ inputs.build_dir }}
+        cmake --build . --config ${{ inputs.configuration }} --parallel $(nproc)
+
+    - name: Show ccache statistics
+      if: inputs.ccache_enabled == 'true'
+      shell: bash
+      run: ccache -s
+
+    - name: Save ccache directory
+      if: inputs.ccache_enabled == 'true'
+      uses: actions/cache/save@v4
+      with:
+        path: ~/.ccache
+        key: ${{ steps.ccache-restore.outputs.cache-primary-key }}

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

@@ -0,0 +1,86 @@
+name: dependencies
+description: 'Installs build dependencies with caching'
+
+inputs:
+  configuration:
+    description: 'Build configuration (Debug, Release, etc.)'
+    required: true
+  build_dir:
+    description: 'Directory to build dependencies in'
+    required: false
+    default: '.build'
+  compiler-id:
+    description: 'Unique identifier for compiler/version combination used for cache keys'
+    required: false
+    default: ''
+  cache_version:
+    description: 'Cache version for invalidation'
+    required: false
+    default: '1'
+  cache_enabled:
+    description: 'Whether to use caching'
+    required: false
+    default: 'true'
+  main_branch:
+    description: 'Main branch name for restore keys'
+    required: false
+    default: 'dev'
+
+outputs:
+  cache-hit:
+    description: 'Whether there was a cache hit'
+    value: ${{ steps.cache-restore-conan.outputs.cache-hit }}
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Generate safe branch name
+      if: inputs.cache_enabled == 'true'
+      id: safe-branch
+      shell: bash
+      run: |
+        SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr -c 'a-zA-Z0-9_.-' '-')
+        echo "name=${SAFE_BRANCH}" >> $GITHUB_OUTPUT
+
+    - name: Restore Conan cache
+      if: inputs.cache_enabled == 'true'
+      id: cache-restore-conan
+      uses: actions/cache/restore@v4
+      with:
+        path: |
+          ~/.conan
+          ~/.conan2
+        key: ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.txt', '**/conanfile.py') }}-${{ inputs.configuration }}
+        restore-keys: |
+          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.txt', '**/conanfile.py') }}-
+          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
+          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-
+
+    - name: Export custom recipes
+      shell: bash
+      run: |
+        conan export external/snappy snappy/1.1.9@
+        conan export external/soci soci/4.0.3@
+
+    - name: Install dependencies
+      shell: bash
+      run: |
+        # Create build directory
+        mkdir -p ${{ inputs.build_dir }}
+        cd ${{ inputs.build_dir }}
+        
+        # Install dependencies using conan
+        conan install \
+          --output-folder . \
+          --build missing \
+          --settings build_type=${{ inputs.configuration }} \
+          ..
+
+    - name: Save Conan cache
+      if: inputs.cache_enabled == 'true' && steps.cache-restore-conan.outputs.cache-hit != 'true'
+      uses: actions/cache/save@v4
+      with:
+        path: |
+          ~/.conan
+          ~/.conan2
+        key: ${{ steps.cache-restore-conan.outputs.cache-primary-key }}

.github/pull_request_template.md

@@ -33,6 +33,7 @@ Please check [x] relevant options, delete irrelevant ones.
 - [ ] New feature (non-breaking change which adds functionality)
 - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
 - [ ] Refactor (non-breaking change that only restructures code)
+- [ ] Performance (increase or change in throughput and/or latency)
 - [ ] Tests (you added tests for code that already exists, or your new feature included in this PR)
 - [ ] Documentation update
 - [ ] Chore (no impact to binary, e.g. `.gitignore`, formatting, dropping support for older tooling)
@@ -58,6 +59,12 @@ Please check [x] relevant options, delete irrelevant ones.
 ## Before / After
 If relevant, use this section for an English description of the change at a technical level.
 If this change affects an API, examples should be included here.
+
+For performance-impacting changes, please provide these details:
+1. Is this a new feature, bug fix, or improvement to existing functionality?
+2. What behavior/functionality does the change impact?
+3. In what processing can the impact be measured? Be as specific as possible - e.g. RPC client call, payment transaction that involves LOB, AMM, caching, DB operations, etc.
+4. Does this change affect concurrent processing - e.g. does it involve acquiring locks, multi-threaded processing, or async processing?
 -->
 
 <!--

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

@@ -2,37 +2,104 @@ name: Build using Docker
 
 on:
   push:
-    branches: [ "dev", "candidate", "release", "jshooks" ]
+    branches: ["dev", "candidate", "release", "jshooks"]
   pull_request:
-    branches: [ "dev", "candidate", "release", "jshooks" ]
+    branches: ["dev", "candidate", "release", "jshooks"]
 
 concurrency:
-  group: ${{ github.workflow }}
-  cancel-in-progress: false
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  DEBUG_BUILD_CONTAINERS_AFTER_CLEANUP: 1
 
 jobs:
   checkout:
     runs-on: [self-hosted, vanity]
+    outputs:
+      checkout_path: ${{ steps.vars.outputs.checkout_path }}
     steps:
-    - uses: actions/checkout@v3
-      with:
-        clean: false
+      - name: Prepare checkout path
+        id: vars
+        run: |
+          SAFE_BRANCH=$(echo "${{ github.ref_name }}" | sed -e 's/[^a-zA-Z0-9._-]/-/g')
+          CHECKOUT_PATH="${SAFE_BRANCH}-${{ github.sha }}"
+          echo "checkout_path=${CHECKOUT_PATH}" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/checkout@v4
+        with:
+          path: ${{ steps.vars.outputs.checkout_path }}
+          clean: true
+          fetch-depth: 2 # Only get the last 2 commits, to avoid fetching all history
+
   checkpatterns:
     runs-on: [self-hosted, vanity]
     needs: checkout
+    defaults:
+      run:
+        working-directory: ${{ needs.checkout.outputs.checkout_path }}
     steps:
-    - name: Check for suspicious patterns
-      run: /bin/bash suspicious_patterns.sh
+      - name: Check for suspicious patterns
+        run: /bin/bash suspicious_patterns.sh
+
   build:
     runs-on: [self-hosted, vanity]
-    needs: checkpatterns
+    needs: [checkpatterns, checkout]
+    defaults:
+      run:
+        working-directory: ${{ needs.checkout.outputs.checkout_path }}
     steps:
-    - name: Build using Docker
-      run: /bin/bash release-builder.sh
+      - name: Set Cleanup Script Path
+        run: |
+          echo "JOB_CLEANUP_SCRIPT=$(mktemp)" >> $GITHUB_ENV
+
+      - name: Build using Docker
+        run: /bin/bash release-builder.sh
+
+      - name: Stop Container (Cleanup)
+        if: always()
+        run: |
+          echo "Running cleanup script: $JOB_CLEANUP_SCRIPT"
+          /bin/bash -e -x "$JOB_CLEANUP_SCRIPT"
+          CLEANUP_EXIT_CODE=$?
+
+          if [[ "$CLEANUP_EXIT_CODE" -eq 0 ]]; then
+            echo "Cleanup script succeeded."
+            rm -f "$JOB_CLEANUP_SCRIPT"
+            echo "Cleanup script removed."
+          else
+            echo "⚠️ Cleanup script failed! Keeping for debugging: $JOB_CLEANUP_SCRIPT"
+          fi
+
+          if [[ "${DEBUG_BUILD_CONTAINERS_AFTER_CLEANUP}" == "1" ]]; then
+            echo "🔍 Checking for leftover containers..."
+            BUILD_CONTAINERS=$(docker ps --format '{{.Names}}' | grep '^xahaud_cached_builder' || echo "")
+
+            if [[ -n "$BUILD_CONTAINERS" ]]; then
+              echo "⚠️ WARNING: Some build containers are still running"
+              echo "$BUILD_CONTAINERS"
+            else
+              echo "✅ No build containers found"
+            fi
+          fi
+
   tests:
     runs-on: [self-hosted, vanity]
-    needs: build
+    needs: [build, checkout]
+    defaults:
+      run:
+        working-directory: ${{ needs.checkout.outputs.checkout_path }}
     steps:
-    - name: Unit tests
-      run: /bin/bash docker-unit-tests.sh
+      - name: Unit tests
+        run: /bin/bash docker-unit-tests.sh
 
+  cleanup:
+    runs-on: [self-hosted, vanity]
+    needs: [tests, checkout]
+    if: always()
+    steps:
+      - name: Cleanup workspace
+        run: |
+          CHECKOUT_PATH="${{ needs.checkout.outputs.checkout_path }}"
+          echo "Cleaning workspace for ${CHECKOUT_PATH}"
+          rm -rf "${{ github.workspace }}/${CHECKOUT_PATH}"

.github/workflows/checkpatterns.yml

@@ -0,0 +1,20 @@
+name: checkpatterns
+
+on: [push, pull_request]
+
+jobs:
+  checkpatterns:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Check for suspicious patterns
+        run: |
+          if [ -f "suspicious_patterns.sh" ]; then
+            bash suspicious_patterns.sh
+          else
+            echo "Warning: suspicious_patterns.sh not found, skipping check"
+            # Still exit with success for compatibility with dependent jobs
+            exit 0
+          fi

.github/workflows/clang-format.yml

@@ -4,21 +4,32 @@ on: [push, pull_request]
 
 jobs:
   check:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     env:
       CLANG_VERSION: 10
     steps:
     - uses: actions/checkout@v3
-    - name: Install clang-format
+    # - name: Install clang-format
+    #   run: |
+    #     codename=$( lsb_release --codename --short )
+    #     sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
+    #     deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
+    #     deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
+    #     EOF
+    #     wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
+    #     sudo apt-get update -y
+    #     sudo apt-get install -y clang-format-${CLANG_VERSION}
+
+    # Temporary fix until this commit is merged
+    # https://github.com/XRPLF/rippled/commit/552377c76f55b403a1c876df873a23d780fcc81c
+    - name: Download and install clang-format
       run: |
-        codename=$( lsb_release --codename --short )
-        sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
-        deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-        deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-        EOF
-        wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
-        sudo apt-get update
-        sudo apt-get install clang-format-${CLANG_VERSION}
+        sudo apt-get update -y
+        sudo apt-get install -y libtinfo5
+        curl -LO https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.1/clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+        tar -xf clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+        sudo mv clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04 /opt/clang-10
+        sudo ln -s /opt/clang-10/bin/clang-format /usr/local/bin/clang-format-10
     - name: Format src/ripple
       run: find src/ripple -type f \( -name '*.cpp' -o -name '*.h' -o -name '*.ipp' \) -print0 | xargs -0 clang-format-${CLANG_VERSION} -i
     - name: Format src/test
@@ -30,7 +41,7 @@ jobs:
         git diff --exit-code | tee "clang-format.patch"
     - name: Upload patch
       if: failure() && steps.assert.outcome == 'failure'
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       continue-on-error: true
       with:
         name: clang-format.patch

.github/workflows/doxygen.yml

@@ -1,25 +0,0 @@
-name: Build and publish Doxygen documentation
-on:
-  push:
-    branches:
-      - dev
-
-jobs:
-  job:
-    runs-on: ubuntu-latest
-    container:
-      image: docker://rippleci/rippled-ci-builder:2944b78d22db
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: build
-        run: |
-          mkdir build
-          cd build
-          cmake -DBoost_NO_BOOST_CMAKE=ON ..
-          cmake --build . --target docs --parallel $(nproc)
-      - name: publish
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: build/docs/html

.github/workflows/levelization.yml

@@ -18,7 +18,7 @@ jobs:
         git diff --exit-code | tee "levelization.patch"
     - name: Upload patch
       if: failure() && steps.assert.outcome == 'failure'
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       continue-on-error: true
       with:
         name: levelization.patch

.github/workflows/nix.yml

@@ -1,95 +0,0 @@
-name: nix
-on: [push, pull_request]
-
-jobs:
-
-  test:
-    strategy:
-      matrix:
-        platform:
-          - ubuntu-latest
-          - macos-12
-        generator:
-          - Ninja
-        configuration:
-          - Release
-    runs-on: ${{ matrix.platform }}
-    env:
-      build_dir: .build
-    steps:
-      - name: checkout
-        uses: actions/checkout@v3
-      - name: install Ninja on Linux
-        if: matrix.generator == 'Ninja' && runner.os == 'Linux'
-        run: sudo apt install ninja-build
-      - name: install Ninja on OSX
-        if: matrix.generator == 'Ninja' && runner.os == 'macOS'
-        run: brew install ninja
-      - name: install nproc on OSX
-        if: runner.os == 'macOS'
-        run: brew install coreutils
-      - name: choose Python
-        uses: actions/setup-python@v3
-        with:
-          python-version: 3.9
-      - name: learn Python cache directory
-        id: pip-cache
-        run: |
-          sudo pip install --upgrade pip
-          echo "::set-output name=dir::$(pip cache dir)"
-      - name: restore Python cache directory
-        uses: actions/cache@v2
-        with:
-            path: ${{ steps.pip-cache.outputs.dir }}
-            key: ${{ runner.os }}-${{ hashFiles('.github/workflows/nix.yml') }}
-      - name: install Conan
-        run: pip install wheel 'conan>=1.52.0'
-      - name: check environment
-        run: |
-          echo ${PATH} | tr ':' '\n'
-          python --version
-          conan --version
-          cmake --version
-          env
-      - name: configure Conan
-        run: |
-          conan profile new default --detect
-          conan profile update settings.compiler.cppstd=20 default
-      - name: configure Conan on Linux
-        if: runner.os == 'Linux'
-        run: |
-          conan profile update settings.compiler.libcxx=libstdc++11 default
-      - name: learn Conan cache directory
-        id: conan-cache
-        run: |
-          echo "::set-output name=dir::$(conan config get storage.path)"
-      - name: restore Conan cache directory
-        uses: actions/cache@v2
-        with:
-            path: ${{ steps.conan-cache.outputs.dir }}
-            key: ${{ hashFiles('~/.conan/profiles/default', 'conanfile.py', 'external/rocksdb/*', '.github/workflows/nix.yml') }}
-      - name: export RocksDB
-        run: conan export external/rocksdb
-      - name: install dependencies
-        run: |
-          mkdir ${build_dir}
-          cd ${build_dir}
-          conan install .. --build missing --settings build_type=${{ matrix.configuration }} --profile:build default --profile:host default
-      - name: configure
-        run: |
-          cd ${build_dir}
-          cmake \
-            -G ${{ matrix.generator }} \
-            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
-            -DCMAKE_BUILD_TYPE=${{ matrix.configuration }} \
-            -Dassert=ON \
-            -Dcoverage=OFF \
-            -Dreporting=OFF \
-            -Dunity=OFF \
-            ..
-      - name: build
-        run: |
-          cmake --build ${build_dir} --target rippled --parallel $(nproc)
-      - name: test
-        run: |
-          ${build_dir}/rippled --unittest --unittest-jobs $(nproc)

.github/workflows/windows.yml

@@ -1,89 +0,0 @@
-name: windows
-# We have disabled this workflow because it fails in our CI Windows
-# environment, but we cannot replicate the failure in our personal Windows
-# test environments, nor have we gone through the trouble of setting up an
-# interactive CI Windows environment.
-# We welcome contributions to diagnose or debug the problems on Windows. Until
-# then, we leave this tombstone as a reminder that we have tried (but failed)
-# to write a reliable test for Windows.
-# on: [push, pull_request]
-
-jobs:
-
-  test:
-    strategy:
-      matrix:
-        generator:
-          - Visual Studio 16 2019
-        configuration:
-          - Release
-    runs-on: windows-2019
-    env:
-      build_dir: .build
-    steps:
-      - name: checkout
-        uses: actions/checkout@v3
-      - name: choose Python
-        uses: actions/setup-python@v3
-        with:
-          python-version: 3.9
-      - name: learn Python cache directory
-        id: pip-cache
-        run: |
-          pip install --upgrade pip
-          echo "::set-output name=dir::$(pip cache dir)"
-      - name: restore Python cache directory
-        uses: actions/cache@v2
-        with:
-            path: ${{ steps.pip-cache.outputs.dir }}
-            key: ${{ runner.os }}-${{ hashFiles('.github/workflows/windows.yml') }}
-      - name: install Conan
-        run: pip install wheel 'conan>=1.52.0'
-      - name: check environment
-        run: |
-          $env:PATH -split ';'
-          python --version
-          conan --version
-          cmake --version
-          dir env:
-      - name: configure Conan
-        run: |
-          conan profile new default --detect
-          conan profile update settings.compiler.cppstd=20 default
-          conan profile update settings.compiler.runtime=MT default
-          conan profile update settings.compiler.toolset=v141 default
-      - name: learn Conan cache directory
-        id: conan-cache
-        run: |
-          echo "::set-output name=dir::$(conan config get storage.path)"
-      - name: restore Conan cache directory
-        uses: actions/cache@v2
-        with:
-            path: ${{ steps.conan-cache.outputs.dir }}
-            key: ${{ hashFiles('~/.conan/profiles/default', 'conanfile.py', 'external/rocksdb/*', '.github/workflows/windows.yml') }}
-      - name: export RocksDB
-        run: conan export external/rocksdb
-      - name: install dependencies
-        run: |
-          mkdir $env:build_dir
-          cd $env:build_dir
-          conan install .. --build missing --settings build_type=${{ matrix.configuration }}
-      - name: configure
-        run: |
-          $env:build_dir
-          cd $env:build_dir
-          pwd
-          ls
-          cmake `
-            -G "${{ matrix.generator }}" `
-            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake `
-            -Dassert=ON `
-            -Dreporting=OFF `
-            -Dunity=OFF `
-            ..
-      - name: build
-        run: |
-          cmake --build $env:build_dir --target rippled --config ${{ matrix.configuration }} --parallel $env:NUMBER_OF_PROCESSORS
-      - name: test
-        run: |
-          & "$env:build_dir\${{ matrix.configuration }}\rippled.exe" --unittest

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

@@ -0,0 +1,116 @@
+name: MacOS - GA Runner
+
+on:
+  push:
+    branches: ["dev", "candidate", "release"]
+  pull_request:
+    branches: ["dev", "candidate", "release"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        generator:
+          - Ninja
+        configuration:
+          - Debug
+    runs-on: macos-15
+    env:
+      build_dir: .build
+      # Bump this number to invalidate all caches globally.
+      CACHE_VERSION: 1
+      MAIN_BRANCH_NAME: dev
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Conan
+        run: |
+          brew install conan@1
+          # Add Conan 1 to the PATH for this job
+          echo "$(brew --prefix conan@1)/bin" >> $GITHUB_PATH
+
+      - name: Install Coreutils
+        run: |
+          brew install coreutils
+          echo "Num proc: $(nproc)"
+
+      - name: Install Ninja
+        if: matrix.generator == 'Ninja'
+        run: brew install ninja
+
+      - name: Install Python
+        run: |
+          if which python3 > /dev/null 2>&1; then
+              echo "Python 3 executable exists"
+              python3 --version
+          else
+              brew install python@3.12
+          fi
+          # Create 'python' symlink if it doesn't exist (for tools expecting 'python')
+          if ! which python > /dev/null 2>&1; then
+              sudo ln -sf $(which python3) /usr/local/bin/python
+          fi
+
+      - name: Install CMake
+        run: |
+          if which cmake > /dev/null 2>&1; then
+              echo "cmake executable exists"
+              cmake --version
+          else
+              brew install cmake
+          fi
+
+      - name: Install ccache
+        run: brew install ccache
+
+      - name: Configure ccache
+        uses: ./.github/actions/xahau-configure-ccache
+        with:
+          max_size: 2G
+          hash_dir: true
+          compiler_check: content
+
+      - name: Check environment
+        run: |
+          echo "PATH:"
+          echo "${PATH}" | tr ':' '\n'
+          which python && python --version || echo "Python not found"
+          which conan && conan --version || echo "Conan not found"
+          which cmake && cmake --version || echo "CMake not found"
+          clang --version
+          ccache --version
+          echo "---- Full Environment ----"
+          env
+
+      - name: Configure Conan
+        run: |
+          conan profile new default --detect || true # Ignore error if profile exists
+          conan profile update settings.compiler.cppstd=20 default
+
+      - name: Install dependencies
+        uses: ./.github/actions/xahau-ga-dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          compiler-id: clang
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+
+      - name: Build
+        uses: ./.github/actions/xahau-ga-build
+        with:
+          generator: ${{ matrix.generator }}
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          compiler-id: clang
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+
+      - name: Test
+        run: |
+          ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)

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

@@ -0,0 +1,123 @@
+name: Nix - GA Runner
+
+on:
+  push:
+    branches: ["dev", "candidate", "release"]
+  pull_request:
+    branches: ["dev", "candidate", "release"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-job:
+    runs-on: ubuntu-latest
+    outputs:
+      artifact_name: ${{ steps.set-artifact-name.outputs.artifact_name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [gcc]
+        configuration: [Debug]
+        include:
+          - compiler: gcc
+            cc: gcc-11
+            cxx: g++-11
+            compiler_id: gcc-11
+    env:
+      build_dir: .build
+      # Bump this number to invalidate all caches globally.
+      CACHE_VERSION: 1
+      MAIN_BRANCH_NAME: dev
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ninja-build ${{ matrix.cc }} ${{ matrix.cxx }} ccache
+          # Install specific Conan version needed
+          pip install --upgrade "conan<2"
+
+      - name: Configure ccache
+        uses: ./.github/actions/xahau-configure-ccache
+        with:
+          max_size: 2G
+          hash_dir: true
+          compiler_check: content
+
+      - name: Configure Conan
+        run: |
+          conan profile new default --detect || true # Ignore error if profile exists
+          conan profile update settings.compiler.cppstd=20 default
+          conan profile update settings.compiler=${{ matrix.compiler }} default
+          conan profile update settings.compiler.libcxx=libstdc++11 default
+          conan profile update env.CC=/usr/bin/${{ matrix.cc }} default
+          conan profile update env.CXX=/usr/bin/${{ matrix.cxx }} default
+          conan profile update conf.tools.build:compiler_executables='{"c": "/usr/bin/${{ matrix.cc }}", "cpp": "/usr/bin/${{ matrix.cxx }}"}' default
+
+          # Set correct compiler version based on matrix.compiler
+          if [ "${{ matrix.compiler }}" = "gcc" ]; then
+            conan profile update settings.compiler.version=11 default
+          elif [ "${{ matrix.compiler }}" = "clang" ]; then
+            conan profile update settings.compiler.version=14 default
+          fi
+          # Display profile for verification
+          conan profile show default
+
+      - name: Check environment
+        run: |
+          echo "PATH:"
+          echo "${PATH}" | tr ':' '\n'
+          which conan && conan --version || echo "Conan not found"
+          which cmake && cmake --version || echo "CMake not found"
+          which ${{ matrix.cc }} && ${{ matrix.cc }} --version || echo "${{ matrix.cc }} not found"
+          which ${{ matrix.cxx }} && ${{ matrix.cxx }} --version || echo "${{ matrix.cxx }} not found"
+          which ccache && ccache --version || echo "ccache not found"
+          echo "---- Full Environment ----"
+          env
+
+      - name: Install dependencies
+        uses: ./.github/actions/xahau-ga-dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          compiler-id: ${{ matrix.compiler_id }}
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+
+      - name: Build
+        uses: ./.github/actions/xahau-ga-build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          cc: ${{ matrix.cc }}
+          cxx: ${{ matrix.cxx }}
+          compiler-id: ${{ matrix.compiler_id }}
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+
+      - name: Set artifact name
+        id: set-artifact-name
+        run: |
+          ARTIFACT_NAME="build-output-nix-${{ github.run_id }}-${{ matrix.compiler }}-${{ matrix.configuration }}"
+          echo "artifact_name=${ARTIFACT_NAME}" >> "$GITHUB_OUTPUT"
+          echo "Using artifact name: ${ARTIFACT_NAME}"
+
+      - name: Debug build directory
+        run: |
+          echo "Checking build directory contents: ${{ env.build_dir }}"
+          ls -la ${{ env.build_dir }} || echo "Build directory not found or empty"
+
+      - name: Run tests
+        run: |
+          # Ensure the binary exists before trying to run
+          if [ -f "${{ env.build_dir }}/rippled" ]; then
+            ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)
+          else
+             echo "Error: rippled executable not found in ${{ env.build_dir }}"
+             exit 1
+          fi

.gitignore

@@ -114,3 +114,9 @@ pkg_out
 pkg
 CMakeUserPresets.json
 bld.rippled/
+
+generated
+.vscode
+
+# Suggested in-tree build directory
+/.build/

.vscode/settings.json

@@ -3,7 +3,7 @@
   "C_Cpp.clang_format_path": ".clang-format",
   "C_Cpp.clang_format_fallbackStyle": "{ ColumnLimit: 0 }",
   "[cpp]":{
-    "editor.wordBasedSuggestions": false,
+    "editor.wordBasedSuggestions": "off",
     "editor.suggest.insertMode": "replace",
     "editor.semanticHighlighting.enabled": true,
     "editor.tabSize": 4,

API-CHANGELOG.md

@@ -0,0 +1,199 @@
+# API Changelog
+
+This changelog is intended to list all updates to the [public API methods](https://xrpl.org/public-api-methods.html).
+
+For info about how [API versioning](https://xrpl.org/request-formatting.html#api-versioning) works, including examples, please view the [XLS-22d spec](https://github.com/XRPLF/XRPL-Standards/discussions/54). For details about the implementation of API versioning, view the [implementation PR](https://github.com/XRPLF/rippled/pull/3155). API versioning ensures existing integrations and users continue to receive existing behavior, while those that request a higher API version will experience new behavior.
+
+The API version controls the API behavior you see. This includes what properties you see in responses, what parameters you're permitted to send in requests, and so on. You specify the API version in each of your requests. When a breaking change is introduced to the `rippled` API, a new version is released. To avoid breaking your code, you should set (or increase) your version when you're ready to upgrade.
+
+For a log of breaking changes, see the **API Version [number]** headings. In general, breaking changes are associated with a particular API Version number. For non-breaking changes, scroll to the **XRP Ledger version [x.y.z]** headings. Non-breaking changes are associated with a particular XRP Ledger (`rippled`) release.
+
+## API Version 1
+
+This version is supported by all `rippled` versions. At time of writing, it is the default API version, used when no `api_version` is specified. When a new API version is introduced, the command line interface will default to the latest API version. The command line is intended for ad-hoc usage by humans, not programs or automated scripts. The command line is not meant for use in production code.
+
+### Idiosyncrasies
+
+#### V1 account_info response
+
+In [the response to the `account_info` command](https://xrpl.org/account_info.html#response-format), there is `account_data` - which is supposed to be an `AccountRoot` object - and `signer_lists` is returned in this object. However, the docs say that `signer_lists` should be at the root level of the reponse.
+
+It makes sense for `signer_lists` to be at the root level because signer lists are not part of the AccountRoot object. (First reported in [xrpl-dev-portal#938](https://github.com/XRPLF/xrpl-dev-portal/issues/938).)
+
+In `api_version: 2`, the `signer_lists` field [will be moved](#modifications-to-account_info-response-in-v2) to the root level of the account_info response. (https://github.com/XRPLF/rippled/pull/3770)
+
+#### server_info - network_id
+
+The `network_id` field was added in the `server_info` response in version 1.5.0 (2019), but it is not returned in [reporting mode](https://xrpl.org/rippled-server-modes.html#reporting-mode).
+
+## XRP Ledger server version 2.0.0
+
+### Additions in 2.2
+
+Additions are intended to be non-breaking (because they are purely additive).
+
+- `feature`: A non-admin mode that uses the same formatting as admin RPC, but hides potentially-sensitive data.
+
+### Additions in 2.0
+
+Additions are intended to be non-breaking (because they are purely additive).
+
+- `server_definitions`: A new RPC that generates a `definitions.json`-like output that can be used in XRPL libraries.
+- In `Payment` transactions, `DeliverMax` has been added. This is a replacement for the `Amount` field, which should not be used. Typically, the `delivered_amount` (in transaction metadata) should be used. To ease the transition, `DeliverMax` is present regardless of API version, since adding a field is non-breaking.
+- API version 2 has been moved from beta to supported, meaning that it is generally available (regardless of the `beta_rpc_api` setting).
+
+## XRP Ledger server version 1.12.0
+
+[Version 1.12.0](https://github.com/XRPLF/rippled/releases/tag/1.12.0) was released on Sep 6, 2023.
+
+### Additions in 1.12
+
+Additions are intended to be non-breaking (because they are purely additive).
+
+- `server_info`: Added `ports`, an array which advertises the RPC and WebSocket ports. This information is also included in the `/crawl` endpoint (which calls `server_info` internally). `grpc` and `peer` ports are also included. (https://github.com/XRPLF/rippled/pull/4427)
+  - `ports` contains objects, each containing a `port` for the listening port (a number string), and a `protocol` array listing the supported protocols on that port.
+  - This allows crawlers to build a more detailed topology without needing to port-scan nodes.
+  - (For peers and other non-admin clients, the info about admin ports is excluded.)
+- Clawback: The following additions are gated by the Clawback amendment (`featureClawback`). (https://github.com/XRPLF/rippled/pull/4553)
+  - Adds an [AccountRoot flag](https://xrpl.org/accountroot.html#accountroot-flags) called `lsfAllowTrustLineClawback` (https://github.com/XRPLF/rippled/pull/4617)
+    - Adds the corresponding `asfAllowTrustLineClawback` [AccountSet Flag](https://xrpl.org/accountset.html#accountset-flags) as well.
+    - Clawback is disabled by default, so if an issuer desires the ability to claw back funds, they must use an `AccountSet` transaction to set the AllowTrustLineClawback flag. They must do this before creating any trust lines, offers, escrows, payment channels, or checks.
+  - Adds the [Clawback transaction type](https://github.com/XRPLF/XRPL-Standards/blob/master/XLS-39d-clawback/README.md#331-clawback-transaction), containing these fields:
+    - `Account`: The issuer of the asset being clawed back. Must also be the sender of the transaction.
+    - `Amount`: The amount being clawed back, with the `Amount.issuer` being the token holder's address.
+- Adds [AMM](https://github.com/XRPLF/XRPL-Standards/discussions/78) ([#4294](https://github.com/XRPLF/rippled/pull/4294), [#4626](https://github.com/XRPLF/rippled/pull/4626)) feature:
+  - Adds `amm_info` API to retrieve AMM information for a given tokens pair.
+  - Adds `AMMCreate` transaction type to create `AMM` instance.
+  - Adds `AMMDeposit` transaction type to deposit funds into `AMM` instance.
+  - Adds `AMMWithdraw` transaction type to withdraw funds from `AMM` instance.
+  - Adds `AMMVote` transaction type to vote for the trading fee of `AMM` instance.
+  - Adds `AMMBid` transaction type to bid for the Auction Slot of `AMM` instance.
+  - Adds `AMMDelete` transaction type to delete `AMM` instance.
+  - Adds `sfAMMID` to `AccountRoot` to indicate that the account is `AMM`'s account. `AMMID` is used to fetch `ltAMM`.
+  - Adds `lsfAMMNode` `TrustLine` flag to indicate that one side of the `TrustLine` is `AMM` account.
+  - Adds `tfLPToken`, `tfSingleAsset`, `tfTwoAsset`, `tfOneAssetLPToken`, `tfLimitLPToken`, `tfTwoAssetIfEmpty`,
+    `tfWithdrawAll`, `tfOneAssetWithdrawAll` which allow a trader to specify different fields combination
+    for `AMMDeposit` and `AMMWithdraw` transactions.
+  - Adds new transaction result codes:
+    - tecUNFUNDED_AMM: insufficient balance to fund AMM. The account does not have funds for liquidity provision.
+    - tecAMM_BALANCE: AMM has invalid balance. Calculated balances greater than the current pool balances.
+    - tecAMM_FAILED: AMM transaction failed. Fails due to a processing failure.
+    - tecAMM_INVALID_TOKENS: AMM invalid LP tokens. Invalid input values, format, or calculated values.
+    - tecAMM_EMPTY: AMM is in empty state. Transaction requires AMM in non-empty state (LP tokens > 0).
+    - tecAMM_NOT_EMPTY: AMM is not in empty state. Transaction requires AMM in empty state (LP tokens == 0).
+    - tecAMM_ACCOUNT: AMM account. Clawback of AMM account.
+    - tecINCOMPLETE: Some work was completed, but more submissions required to finish. AMMDelete partially deletes the trustlines.
+
+## XRP Ledger server version 1.11.0
+
+[Version 1.11.0](https://github.com/XRPLF/rippled/releases/tag/1.11.0) was released on Jun 20, 2023.
+
+### Breaking changes in 1.11
+
+- Added the ability to mark amendments as obsolete. For the `feature` admin API, there is a new possible value for the `vetoed` field. (https://github.com/XRPLF/rippled/pull/4291)
+  - The value of `vetoed` can now be `true`, `false`, or `"Obsolete"`.
+- Removed the acceptance of seeds or public keys in place of account addresses. (https://github.com/XRPLF/rippled/pull/4404)
+  - This simplifies the API and encourages better security practices (i.e. seeds should never be sent over the network).
+- For the `ledger_data` method, when all entries are filtered out, the `state` field of the response is now an empty list (in other words, an empty array, `[]`). (Previously, it would return `null`.) While this is technically a breaking change, the new behavior is consistent with the documentation, so this is considered only a bug fix. (https://github.com/XRPLF/rippled/pull/4398)
+- If and when the `fixNFTokenRemint` amendment activates, there will be a new AccountRoot field, `FirstNFTSequence`. This field is set to the current account sequence when the account issues their first NFT. If an account has not issued any NFTs, then the field is not set. ([#4406](https://github.com/XRPLF/rippled/pull/4406))
+  - There is a new account deletion restriction: an account can only be deleted if `FirstNFTSequence` + `MintedNFTokens` + `256` is less than the current ledger sequence.
+  - This is potentially a breaking change if clients have logic for determining whether an account can be deleted.
+- NetworkID
+  - For sidechains and networks with a network ID greater than 1024, there is a new [transaction common field](https://xrpl.org/transaction-common-fields.html), `NetworkID`. (https://github.com/XRPLF/rippled/pull/4370)
+    - This field helps to prevent replay attacks and is now required for chains whose network ID is 1025 or higher.
+    - The field must be omitted for Mainnet, so there is no change for Mainnet users.
+  - There are three new local error codes:
+    - `telNETWORK_ID_MAKES_TX_NON_CANONICAL`: a `NetworkID` is present but the chain's network ID is less than 1025. Remove the field from the transaction, and try again.
+    - `telREQUIRES_NETWORK_ID`: a `NetworkID` is required, but is not present. Add the field to the transaction, and try again.
+    - `telWRONG_NETWORK`: a `NetworkID` is specified, but it is for a different network. Submit the transaction to a different server which is connected to the correct network.
+
+### Additions and bug fixes in 1.11
+
+- Added `nftoken_id`, `nftoken_ids` and `offer_id` meta fields into NFT `tx` and `account_tx` responses. (https://github.com/XRPLF/rippled/pull/4447)
+- Added an `account_flags` object to the `account_info` method response. (https://github.com/XRPLF/rippled/pull/4459)
+- Added `NFTokenPages` to the `account_objects` RPC. (https://github.com/XRPLF/rippled/pull/4352)
+- Fixed: `marker` returned from the `account_lines` command would not work on subsequent commands. (https://github.com/XRPLF/rippled/pull/4361)
+
+## XRP Ledger server version 1.10.0
+
+[Version 1.10.0](https://github.com/XRPLF/rippled/releases/tag/1.10.0)
+was released on Mar 14, 2023.
+
+### Breaking changes in 1.10
+
+- If the `XRPFees` feature is enabled, the `fee_ref` field will be
+  removed from the [ledger subscription stream](https://xrpl.org/subscribe.html#ledger-stream), because it will no longer
+  have any meaning.
+
+## API Version 2
+
+API version 2 is introduced in `rippled` version 2.0. Users can request it explicitly by specifying `"api_version" : 2`.
+
+#### Removed methods
+
+In API version 2, the following deprecated methods are no longer available: (https://github.com/XRPLF/rippled/pull/4759)
+
+- `tx_history` - Instead, use other methods such as `account_tx` or `ledger` with the `transactions` field set to `true`.
+- `ledger_header` - Instead, use the `ledger` method.
+
+#### Modifications to JSON transaction element in V2
+
+In API version 2, JSON elements for transaction output have been changed and made consistent for all methods which output transactions. (https://github.com/XRPLF/rippled/pull/4775)
+This helps to unify the JSON serialization format of transactions. (https://github.com/XRPLF/clio/issues/722, https://github.com/XRPLF/rippled/issues/4727)
+
+- JSON transaction element is named `tx_json`
+- Binary transaction element is named `tx_blob`
+- JSON transaction metadata element is named `meta`
+- Binary transaction metadata element is named `meta_blob`
+
+Additionally, these elements are now consistently available next to `tx_json` (i.e. sibling elements), where possible:
+
+- `hash` - Transaction ID. This data was stored inside transaction output in API version 1, but in API version 2 is a sibling element.
+- `ledger_index` - Ledger index (only set on validated ledgers)
+- `ledger_hash` - Ledger hash (only set on closed or validated ledgers)
+- `close_time_iso` - Ledger close time expressed in ISO 8601 time format (only set on validated ledgers)
+- `validated` - Bool element set to `true` if the transaction is in a validated ledger, otherwise `false`
+
+This change affects the following methods:
+
+- `tx` - Transaction data moved into element `tx_json` (was inline inside `result`) or, if binary output was requested, moved from `tx` to `tx_blob`. Renamed binary transaction metadata element (if it was requested) from `meta` to `meta_blob`. Changed location of `hash` and added new elements
+- `account_tx` - Renamed transaction element from `tx` to `tx_json`. Renamed binary transaction metadata element (if it was requested) from `meta` to `meta_blob`. Changed location of `hash` and added new elements
+- `transaction_entry` - Renamed transaction metadata element from `metadata` to `meta`. Changed location of `hash` and added new elements
+- `subscribe` - Renamed transaction element from `transaction` to `tx_json`. Changed location of `hash` and added new elements
+- `sign`, `sign_for`, `submit` and `submit_multisigned` - Changed location of `hash` element.
+
+#### Modification to `Payment` transaction JSON schema
+
+When reading Payments, the `Amount` field should generally **not** be used. Instead, use [delivered_amount](https://xrpl.org/partial-payments.html#the-delivered_amount-field) to see the amount that the Payment delivered. To clarify its meaning, the `Amount` field is being renamed to `DeliverMax`. (https://github.com/XRPLF/rippled/pull/4733)
+
+- In `Payment` transaction type, JSON RPC field `Amount` is renamed to `DeliverMax`. To enable smooth client transition, `Amount` is still handled, as described below: (https://github.com/XRPLF/rippled/pull/4733)
+  - On JSON RPC input (e.g. `submit_multisigned` etc. methods), `Amount` is recognized as an alias to `DeliverMax` for both API version 1 and version 2 clients.
+  - On JSON RPC input, submitting both `Amount` and `DeliverMax` fields is allowed _only_ if they are identical; otherwise such input is rejected with `rpcINVALID_PARAMS` error.
+  - On JSON RPC output (e.g. `subscribe`, `account_tx` etc. methods), `DeliverMax` is present in both API version 1 and version 2.
+  - On JSON RPC output, `Amount` is only present in API version 1 and _not_ in version 2.
+
+#### Modifications to account_info response
+
+- `signer_lists` is returned in the root of the response. In API version 1, it was nested under `account_data`. (https://github.com/XRPLF/rippled/pull/3770)
+- When using an invalid `signer_lists` value, the API now returns an "invalidParams" error. (https://github.com/XRPLF/rippled/pull/4585)
+  - (`signer_lists` must be a boolean. In API version 1, strings were accepted and may return a normal response - i.e. as if `signer_lists` were `true`.)
+
+#### Modifications to [account_tx](https://xrpl.org/account_tx.html#account_tx) response
+
+- Using `ledger_index_min`, `ledger_index_max`, and `ledger_index` returns `invalidParams` because if you use `ledger_index_min` or `ledger_index_max`, then it does not make sense to also specify `ledger_index`. In API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4571)
+  - The same applies for `ledger_index_min`, `ledger_index_max`, and `ledger_hash`. (https://github.com/XRPLF/rippled/issues/4545#issuecomment-1565065579)
+- Using a `ledger_index_min` or `ledger_index_max` beyond the range of ledgers that the server has:
+  - returns `lgrIdxMalformed` in API version 2. Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/issues/4288)
+- Attempting to use a non-boolean value (such as a string) for the `binary` or `forward` parameters returns `invalidParams` (`rpcINVALID_PARAMS`). Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4620)
+
+#### Modifications to [noripple_check](https://xrpl.org/noripple_check.html#noripple_check) response
+
+- Attempting to use a non-boolean value (such as a string) for the `transactions` parameter returns `invalidParams` (`rpcINVALID_PARAMS`). Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4620)
+
+# Unit tests for API changes
+
+The following information is useful to developers contributing to this project:
+
+The purpose of unit tests is to catch bugs and prevent regressions. In general, it often makes sense to create a test function when there is a breaking change to the API. For APIs that have changed in a new API version, the tests should be modified so that both the prior version and the new version are properly tested.
+
+To take one example: for `account_info` version 1, WebSocket and JSON-RPC behavior should be tested. The latest API version, i.e. API version 2, should be tested over WebSocket, JSON-RPC, and command line.

BUILD.md

@@ -1,3 +1,12 @@
+| :warning: **WARNING** :warning:
+|---|
+| These instructions assume you have a C++ development environment ready with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up on Linux, macOS, or Windows, [see this guide](./docs/build/environment.md). |
+
+> These instructions also assume a basic familiarity with Conan and CMake.
+> If you are unfamiliar with Conan,
+> you can read our [crash course](./docs/build/conan.md)
+> or the official [Getting Started][3] walkthrough.
+
 ## Branches
 
 For a stable release, choose the `master` branch or one of the [tagged
@@ -13,216 +22,391 @@ For the latest release candidate, choose the `release` branch.
 git checkout release
 ```
 
-If you are contributing or want the latest set of untested features,
-then use the `develop` branch.
+For the latest set of untested features, or to contribute, choose the `develop`
+branch.
 
 ```
 git checkout develop
 ```
 
+## Minimum Requirements
 
-## Platforms
+See [System Requirements](https://xrpl.org/system-requirements.html).
 
-We do not recommend Windows for rippled production use at this time. Currently,
-the Ubuntu platform has received the highest level of quality assurance,
-testing, and support. Additionally, 32-bit Windows development is not supported.
+Building rippled generally requires git, Python, Conan, CMake, and a C++ compiler. Some guidance on setting up such a [C++ development environment can be found here](./docs/build/environment.md).
 
-Visual Studio 2022 is not yet supported.
-This is because rippled is not compatible with [Boost][] versions 1.78 or 1.79,
-but Conan cannot build Boost versions released earlier than them with VS 2022.
-We expect that rippled will be compatible with Boost 1.80, which should be
-released in August 2022.
-Until then, we advise Windows developers to use Visual Studio 2019.
+- [Python 3.7](https://www.python.org/downloads/)
+- [Conan 1.55](https://conan.io/downloads.html)
+- [CMake 3.16](https://cmake.org/download/)
+
+`rippled` is written in the C++20 dialect and includes the `<concepts>` header.
+The [minimum compiler versions][2] required are:
+
+| Compiler    | Version |
+|-------------|---------|
+| GCC         | 11      |
+| Clang       | 13      |
+| Apple Clang | 13.1.6  |
+| MSVC        | 19.23   |
+
+### Linux
+
+The Ubuntu operating system has received the highest level of
+quality assurance, testing, and support.
+
+Here are [sample instructions for setting up a C++ development environment on Linux](./docs/build/environment.md#linux).
+
+### Mac
+
+Many rippled engineers use macOS for development.
+
+Here are [sample instructions for setting up a C++ development environment on macOS](./docs/build/environment.md#macos).
+
+### Windows
+
+Windows is not recommended for production use at this time.
+
+- Additionally, 32-bit Windows development is not supported.
+- Visual Studio 2022 is not yet supported.
+  - rippled generally requires [Boost][] 1.77, which Conan cannot build with VS 2022.
+  - Until rippled is updated for compatibility with later versions of Boost, Windows developers may need to use Visual Studio 2019.
 
 [Boost]: https://www.boost.org/
 
+## Steps
 
-## Prerequisites
+### Set Up Conan
 
-To build this package, you will need Python (>= 3.7),
-[Conan][] (>= 1.52), and [CMake][] (>= 3.16).
-If you are unfamiliar with Conan,
-there is a crash course at the end of this document.
+After you have a [C++ development environment](./docs/build/environment.md) ready with Git, Python, Conan, CMake, and a C++ compiler, you may need to set up your Conan profile.
 
-[Conan]: https://conan.io/downloads.html
-[CMake]: https://cmake.org/download/
+These instructions assume a basic familiarity with Conan and CMake.
 
-You'll need to compile in the C++20 dialect:
+If you are unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official [Getting Started][3] walkthrough.
 
-```
-conan profile update settings.cppstd=20 default
-```
+You'll need at least one Conan profile:
 
-Linux developers will commonly have a default Conan [profile][] that compiles
+   ```
+   conan profile new default --detect
+   ```
+
+Update the compiler settings:
+
+   ```
+   conan profile update settings.compiler.cppstd=20 default
+   ```
+
+**Linux** developers will commonly have a default Conan [profile][] that compiles
 with GCC and links with libstdc++.
 If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
 then you will need to choose the `libstdc++11` ABI:
 
-```
-conan profile update settings.compiler.libcxx=libstdc++11 default
-```
+   ```
+   conan profile update settings.compiler.libcxx=libstdc++11 default
+   ```
 
-We find it necessary to use the x64 native build tools on Windows.
+**Windows** developers may need to use the x64 native build tools.
 An easy way to do that is to run the shortcut "x64 Native Tools Command
 Prompt" for the version of Visual Studio that you have installed.
 
-Windows developers must build rippled and its dependencies for the x64
-architecture:
+   Windows developers must also build `rippled` and its dependencies for the x64
+   architecture:
 
+   ```
+   conan profile update settings.arch=x86_64 default
+   ```
+
+### Multiple compilers
+
+When `/usr/bin/g++` exists on a platform, it is the default cpp compiler. This
+default works for some users.
+
+However, if this compiler cannot build rippled or its dependencies, then you can
+install another compiler and set Conan and CMake to use it.
+Update the `conf.tools.build:compiler_executables` setting in order to set the correct variables (`CMAKE_<LANG>_COMPILER`) in the
+generated CMake toolchain file.
+For example, on Ubuntu 20, you may have gcc at `/usr/bin/gcc` and g++ at `/usr/bin/g++`; if that is the case, you can select those compilers with:
 ```
-conan profile update settings.arch=x86_64 default
+conan profile update 'conf.tools.build:compiler_executables={"c": "/usr/bin/gcc", "cpp": "/usr/bin/g++"}' default
 ```
 
+Replace `/usr/bin/gcc` and `/usr/bin/g++` with paths to the desired compilers.
 
-## How to build and test
+It should choose the compiler for dependencies as well,
+but not all of them have a Conan recipe that respects this setting (yet).
+For the rest, you can set these environment variables.
+Replace `<path>` with paths to the desired compilers:
 
-Let's start with a couple of examples of common workflows.
-The first is for a single-configuration generator (e.g. Unix Makefiles) on
-Linux or MacOS:
+- `conan profile update env.CC=<path> default`
+- `conan profile update env.CXX=<path> default`
 
-```
-conan export external/rocksdb
-mkdir .build
-cd .build
-conan install .. --output-folder . --build missing --settings build_type=Release
-cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release ..
-cmake --build .
-./rippled --unittest
-```
+Export our [Conan recipe for Snappy](./external/snappy).
+It does not explicitly link the C++ standard library,
+which allows you to statically link it with GCC, if you want.
 
-The second is for a multi-configuration generator (e.g. Visual Studio) on
-Windows:
+   ```
+   conan export external/snappy snappy/1.1.9@
+   ```
 
-```
-conan export external/rocksdb
-mkdir .build
-cd .build
-conan install .. --output-folder . --build missing --settings build_type=Release --settings compiler.runtime=MT
-conan install .. --output-folder . --build missing --settings build_type=Debug --settings compiler.runtime=MTd
-cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
-cmake --build . --config Release
-cmake --build . --config Debug
-./Release/rippled --unittest
-./Debug/rippled --unittest
-```
+Export our [Conan recipe for RocksDB](./external/rocksdb).
+It does not override paths to dependencies when building with Visual Studio.
 
-Here we explain the individual steps:
+   ```
+   conan export external/rocksdb rocksdb/6.29.5@
+   ```
 
-1. Export our [Conan recipe for RocksDB](./external/rocksdb).
+Export our [Conan recipe for SOCI](./external/soci).
+It patches their CMake to correctly import its dependencies.
 
-    It builds version 6.27.3, which, as of July 8, 2022,
-    is not available in [Conan Center](https://conan.io/center/rocksdb).
+   ```
+   conan export external/soci soci/4.0.3@
+   ```
 
-1. Create a build directory (and move into it).
+### Build and Test
 
-    You can choose any name you want.
+1. Create a build directory and move into it.
 
-    Conan will generate some files in what it calls the "install folder".
-    These files are implementation details that you don't need to worry about.
-    By default, the install folder is your current working directory.
-    If you don't move into your build directory before calling Conan,
-    then you may be annoyed to see it polluting your project root directory
-    with these files.
-    To make Conan put them in your build directory,
-    you'll have to add the option
-    `--install-folder` or `-if` to every `conan install` command.
+   ```
+   mkdir .build
+   cd .build
+   ```
 
-1. Generate CMake files for every configuration you want to build.
+   You can use any directory name. Conan treats your working directory as an
+   install folder and generates files with implementation details.
+   You don't need to worry about these files, but make sure to change
+   your working directory to your build directory before calling Conan.
+
+   **Note:** You can specify a directory for the installation files by adding
+   the `install-folder` or `-if` option to every `conan install` command
+   in the next step.
+
+2. Generate CMake files for every configuration you want to build. 
+
+    ```
+    conan install .. --output-folder . --build missing --settings build_type=Release
+    conan install .. --output-folder . --build missing --settings build_type=Debug
+    ```
 
     For a single-configuration generator, e.g. `Unix Makefiles` or `Ninja`,
     you only need to run this command once.
     For a multi-configuration generator, e.g. `Visual Studio`, you may want to
     run it more than once.
 
-    Each of these commands should have a different `build_type` setting.
-    A second command with the same `build_type` setting will just overwrite
-    the files generated by the first.
-    You can pass the build type on the command line with `--settings
-    build_type=$BUILD_TYPE` or in the profile itself, under the section
-    `[settings]`, with the key `build_type`.
-
-    If you are using a Microsoft Visual C++ compiler, then you will need to
-    ensure consistency between the `build_type` setting and the
-    `compiler.runtime` setting.
+    Each of these commands should also have a different `build_type` setting.
+    A second command with the same `build_type` setting will overwrite the files
+    generated by the first. You can pass the build type on the command line with
+    `--settings build_type=$BUILD_TYPE` or in the profile itself,
+    under the section `[settings]` with the key `build_type`.
+    
+    If you are using a Microsoft Visual C++ compiler,
+    then you will need to ensure consistency between the `build_type` setting
+    and the `compiler.runtime` setting.
+    
     When `build_type` is `Release`, `compiler.runtime` should be `MT`.
+    
     When `build_type` is `Debug`, `compiler.runtime` should be `MTd`.
 
-1. Configure CMake once.
+    ```
+    conan install .. --output-folder . --build missing --settings build_type=Release --settings compiler.runtime=MT
+    conan install .. --output-folder . --build missing --settings build_type=Debug --settings compiler.runtime=MTd
+    ```
 
-    For all choices of generator, pass the toolchain file generated by Conan.
-    It will be located at
-    `$OUTPUT_FOLDER/build/generators/conan_toolchain.cmake`.
-    If you are using a single-configuration generator, then pass the CMake
-    variable [`CMAKE_BUILD_TYPE`][build_type] and make sure it matches the
-    `build_type` setting you chose in the previous step.
+3. Configure CMake and pass the toolchain file generated by Conan, located at
+   `$OUTPUT_FOLDER/build/generators/conan_toolchain.cmake`.
 
-    This step is where you may pass build options for rippled.
+    Single-config generators:
+    
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release ..
+    ```
 
-1. Build rippled.
+    Pass the CMake variable [`CMAKE_BUILD_TYPE`][build_type]
+    and make sure it matches the `build_type` setting you chose in the previous
+    step.
 
-    For a multi-configuration generator, you must pass the option `--config`
-    to select the build configuration.
-    For a single-configuration generator, it will build whatever configuration
-    you passed for `CMAKE_BUILD_TYPE`.
+    Multi-config generators:
+
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
+    ```
+
+    **Note:** You can pass build options for `rippled` in this step.
+
+4. Build `rippled`.
+
+   For a single-configuration generator, it will build whatever configuration
+   you passed for `CMAKE_BUILD_TYPE`. For a multi-configuration generator,
+   you must pass the option `--config` to select the build configuration. 
+
+   Single-config generators:
+
+   ```
+   cmake --build .
+   ```
+
+   Multi-config generators:
+    
+   ```
+   cmake --build . --config Release
+   cmake --build . --config Debug
+   ```
 
 5. Test rippled.
 
-    The exact location of rippled in your build directory
-    depends on your choice of CMake generator.
-    You can run unit tests by passing `--unittest`.
-    Pass `--help` to see the rest of the command line options.
+   Single-config generators:
+
+   ```
+   ./rippled --unittest
+   ```
+
+   Multi-config generators:
+
+   ```
+   ./Release/rippled --unittest
+   ./Debug/rippled --unittest
+   ```
+
+   The location of `rippled` in your build directory depends on your CMake
+   generator. Pass `--help` to see the rest of the command line options.
 
 
-### Options
+## Coverage report
 
-The `unity` option allows you to select between [unity][5] and non-unity
-builds.
-Unity builds may be faster for the first build (at the cost of much
-more memory) since they concatenate sources into fewer translation
-units.
-Non-unity builds may be faster for incremental builds, and can be helpful for
-detecting `#include` omissions.
+The coverage report is intended for developers using compilers GCC
+or Clang (including Apple Clang). It is generated by the build target `coverage`,
+which is only enabled when the `coverage` option is set, e.g. with
+`--options coverage=True` in `conan` or `-Dcoverage=ON` variable in `cmake`
 
-Below are the most commonly used options,
-with their default values in parentheses.
+Prerequisites for the coverage report:
 
-- `assert` (OFF): Enable assertions.
-- `reporting` (OFF): Build the reporting mode feature.
-- `tests` (ON): Build tests.
-- `unity` (ON): Configure a [unity build][5].
+- [gcovr tool][gcovr] (can be installed e.g. with [pip][python-pip])
+- `gcov` for GCC (installed with the compiler by default) or
+- `llvm-cov` for Clang (installed with the compiler by default)
+- `Debug` build type
+
+A coverage report is created when the following steps are completed, in order:
+
+1. `rippled` binary built with instrumentation data, enabled by the `coverage`
+   option mentioned above
+2. completed run of unit tests, which populates coverage capture data
+3. completed run of the `gcovr` tool (which internally invokes either `gcov` or `llvm-cov`)
+   to assemble both instrumentation data and the coverage capture data into a coverage report
+
+The above steps are automated into a single target `coverage`. The instrumented
+`rippled` binary can also be used for regular development or testing work, at
+the cost of extra disk space utilization and a small performance hit
+(to store coverage capture). In case of a spurious failure of unit tests, it is
+possible to re-run the `coverage` target without rebuilding the `rippled` binary
+(since it is simply a dependency of the coverage report target). It is also possible
+to select only specific tests for the purpose of the coverage report, by setting
+the `coverage_test` variable in `cmake`
+
+The default coverage report format is `html-details`, but the user
+can override it to any of the formats listed in `Builds/CMake/CodeCoverage.cmake`
+by setting the `coverage_format` variable in `cmake`. It is also possible
+to generate more than one format at a time by setting the `coverage_extra_args`
+variable in `cmake`. The specific command line used to run the `gcovr` tool will be
+displayed if the `CODE_COVERAGE_VERBOSE` variable is set.
+
+By default, the code coverage tool runs parallel unit tests with `--unittest-jobs`
+ set to the number of available CPU cores. This may cause spurious test
+errors on Apple. Developers can override the number of unit test jobs with
+the `coverage_test_parallelism` variable in `cmake`.
+
+Example use with some cmake variables set:
+
+```
+cd .build
+conan install .. --output-folder . --build missing --settings build_type=Debug
+cmake -DCMAKE_BUILD_TYPE=Debug -Dcoverage=ON -Dcoverage_test_parallelism=2 -Dcoverage_format=html-details -Dcoverage_extra_args="--json coverage.json" -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
+cmake --build . --target coverage
+```
+
+After the `coverage` target is completed, the generated coverage report will be
+stored inside the build directory, as either of:
+
+- file named `coverage.`_extension_ , with a suitable extension for the report format, or
+- directory named `coverage`, with the `index.html` and other files inside, for the `html-details` or `html-nested` report formats.
 
 
-### Troubleshooting
+## Options
 
-If you get a linker error like the one below suggesting that you recompile
-Boost with position-independent code, the reason is most likely that Conan
-downloaded a bad binary distribution of the dependency.
-For now, this seems to be a [bug][1] in Conan just for Boost 1.77.0 compiled
-with GCC for Linux.
-The solution is to build the dependency locally by passing `--build boost`
-when calling `conan install`.
+| Option | Default Value | Description |
+| --- | ---| ---|
+| `assert` | OFF | Enable assertions.
+| `reporting` | OFF | Build the reporting mode feature. |
+| `coverage` | OFF | Prepare the coverage report. |
+| `tests` | ON | Build tests. |
+| `unity` | ON | Configure a unity build. |
+| `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
+
+[Unity builds][5] may be faster for the first build
+(at the cost of much more memory) since they concatenate sources into fewer
+translation units. Non-unity builds may be faster for incremental builds,
+and can be helpful for detecting `#include` omissions.
+
+
+## Troubleshooting
+
+
+### Conan
+
+If you have trouble building dependencies after changing Conan settings,
+try removing the Conan cache.
+
+```
+rm -rf ~/.conan/data
+```
+
+
+### no std::result_of
+
+If your compiler version is recent enough to have removed `std::result_of` as
+part of C++20, e.g. Apple Clang 15.0, then you might need to add a preprocessor
+definition to your build.
+
+```
+conan profile update 'options.boost:extra_b2_flags="define=BOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'env.CFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'conf.tools.build:cflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
+conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
+```
+
+
+### recompile with -fPIC
+
+If you get a linker error suggesting that you recompile Boost with
+position-independent code, such as:
+
+```
+/usr/bin/ld.gold: error: /home/username/.conan/data/boost/1.77.0/_/_/package/.../lib/libboost_container.a(alloc_lib.o):
+  requires unsupported dynamic reloc 11; recompile with -fPIC
+```
+
+Conan most likely downloaded a bad binary distribution of the dependency.
+This seems to be a [bug][1] in Conan just for Boost 1.77.0 compiled with GCC
+for Linux. The solution is to build the dependency locally by passing
+`--build boost` when calling `conan install`.
 
 ```
 /usr/bin/ld.gold: error: /home/username/.conan/data/boost/1.77.0/_/_/package/dc8aedd23a0f0a773a5fcdcfe1ae3e89c4205978/lib/libboost_container.a(alloc_lib.o): requires unsupported dynamic reloc 11; recompile with -fPIC
 ```
 
 
-## How to add a dependency
+## Add a Dependency
 
-If you want to experiment with a new package, here are the steps to get it
-working:
+If you want to experiment with a new package, follow these steps:
 
 1. Search for the package on [Conan Center](https://conan.io/center/).
-1. In [`conanfile.py`](./conanfile.py):
-    1. Add a version of the package to the `requires` property.
-    1. Change any default options for the package by adding them to the
-    `default_options` property (with syntax `'$package:$option': $value`)
-1. In [`CMakeLists.txt`](./CMakeLists.txt):
-    1. Add a call to `find_package($package REQUIRED)`.
-    1. Link a library from the package to the target `ripple_libs` (search for
-    the existing call to `target_link_libraries(ripple_libs INTERFACE ...)`).
-1. Start coding! Don't forget to include whatever headers you need from the
-   package.
+2. Modify [`conanfile.py`](./conanfile.py):
+    - Add a version of the package to the `requires` property.
+    - Change any default options for the package by adding them to the
+    `default_options` property (with syntax `'$package:$option': $value`).
+3. Modify [`CMakeLists.txt`](./CMakeLists.txt):
+    - Add a call to `find_package($package REQUIRED)`.
+    - Link a library from the package to the target `ripple_libs`
+    (search for the existing call to `target_link_libraries(ripple_libs INTERFACE ...)`).
+4. Start coding! Don't forget to include whatever headers you need from the package.
 
 
 ## A crash course in CMake and Conan
@@ -340,6 +524,10 @@ but it is more convenient to put them in a [profile][profile].
 
 [1]: https://github.com/conan-io/conan-center-index/issues/13168
 [5]: https://en.wikipedia.org/wiki/Unity_build
+[6]: https://github.com/boostorg/beast/issues/2648
+[7]: https://github.com/boostorg/beast/issues/2661
+[gcovr]: https://gcovr.com/en/stable/getting-started.html
+[python-pip]: https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/
 [build_type]: https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
 [runtime]: https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
 [toolchain]: https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html

Builds/CMake/CMakeFuncs.cmake

@@ -1,4 +1,3 @@
-
 macro(group_sources_in source_dir curdir)
   file(GLOB children RELATIVE ${source_dir}/${curdir}
     ${source_dir}/${curdir}/*)
@@ -29,165 +28,8 @@ macro (exclude_if_included target_)
   endif ()
 endmacro ()
 
-function (print_ep_logs _target)
-  ExternalProject_Get_Property (${_target} STAMP_DIR)
-  add_custom_command(TARGET ${_target} POST_BUILD
-    COMMENT "${_target} BUILD OUTPUT"
-    COMMAND ${CMAKE_COMMAND}
-      -DIN_FILE=${STAMP_DIR}/${_target}-build-out.log
-      -P ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/echo_file.cmake
-    COMMAND ${CMAKE_COMMAND}
-      -DIN_FILE=${STAMP_DIR}/${_target}-build-err.log
-      -P ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/echo_file.cmake)
-endfunction ()
-
-#[=========================================================[
-  This is a function override for one function in the
-  standard ExternalProject module. We want to change
-  the generated build script slightly to include printing
-  the build logs in the case of failure. Those modifications
-  have been made here. This function override could break
-  in the future if the ExternalProject module changes internal
-  function names or changes the way it generates the build
-  scripts.
-   See:
-    https://gitlab.kitware.com/cmake/cmake/blob/df1ddeec128d68cc636f2dde6c2acd87af5658b6/Modules/ExternalProject.cmake#L1855-1952
-#]=========================================================]
-
-function(_ep_write_log_script name step cmd_var)
-  ExternalProject_Get_Property(${name} stamp_dir)
-  set(command "${${cmd_var}}")
-
-  set(make "")
-  set(code_cygpath_make "")
-  if(command MATCHES "^\\$\\(MAKE\\)")
-    # GNU make recognizes the string "$(MAKE)" as recursive make, so
-    # ensure that it appears directly in the makefile.
-    string(REGEX REPLACE "^\\$\\(MAKE\\)" "\${make}" command "${command}")
-    set(make "-Dmake=$(MAKE)")
-
-    if(WIN32 AND NOT CYGWIN)
-      set(code_cygpath_make "
-if(\${make} MATCHES \"^/\")
-  execute_process(
-    COMMAND cygpath -w \${make}
-    OUTPUT_VARIABLE cygpath_make
-    ERROR_VARIABLE cygpath_make
-    RESULT_VARIABLE cygpath_error
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-  if(NOT cygpath_error)
-    set(make \${cygpath_make})
-  endif()
-endif()
-")
-    endif()
-  endif()
-
-  set(config "")
-  if("${CMAKE_CFG_INTDIR}" MATCHES "^\\$")
-    string(REPLACE "${CMAKE_CFG_INTDIR}" "\${config}" command "${command}")
-    set(config "-Dconfig=${CMAKE_CFG_INTDIR}")
-  endif()
-
-  # Wrap multiple 'COMMAND' lines up into a second-level wrapper
-  # script so all output can be sent to one log file.
-  if(command MATCHES "(^|;)COMMAND;")
-    set(code_execute_process "
-${code_cygpath_make}
-execute_process(COMMAND \${command} RESULT_VARIABLE result)
-if(result)
-  set(msg \"Command failed (\${result}):\\n\")
-  foreach(arg IN LISTS command)
-    set(msg \"\${msg} '\${arg}'\")
-  endforeach()
-  message(FATAL_ERROR \"\${msg}\")
-endif()
-")
-    set(code "")
-    set(cmd "")
-    set(sep "")
-    foreach(arg IN LISTS command)
-      if("x${arg}" STREQUAL "xCOMMAND")
-        if(NOT "x${cmd}" STREQUAL "x")
-          string(APPEND code "set(command \"${cmd}\")${code_execute_process}")
-        endif()
-        set(cmd "")
-        set(sep "")
-      else()
-        string(APPEND cmd "${sep}${arg}")
-        set(sep ";")
-      endif()
-    endforeach()
-    string(APPEND code "set(command \"${cmd}\")${code_execute_process}")
-    file(GENERATE OUTPUT "${stamp_dir}/${name}-${step}-$<CONFIG>-impl.cmake" CONTENT "${code}")
-    set(command ${CMAKE_COMMAND} "-Dmake=\${make}" "-Dconfig=\${config}" -P ${stamp_dir}/${name}-${step}-$<CONFIG>-impl.cmake)
-  endif()
-
-  # Wrap the command in a script to log output to files.
-  set(script ${stamp_dir}/${name}-${step}-$<CONFIG>.cmake)
-  set(logbase ${stamp_dir}/${name}-${step})
-  set(code "
-${code_cygpath_make}
-function (_echo_file _fil)
-  file (READ \${_fil} _cont)
-  execute_process (COMMAND \${CMAKE_COMMAND} -E echo \"\${_cont}\")
-endfunction ()
-set(command \"${command}\")
-execute_process(
-  COMMAND \${command}
-  RESULT_VARIABLE result
-  OUTPUT_FILE \"${logbase}-out.log\"
-  ERROR_FILE \"${logbase}-err.log\"
-  )
-if(result)
-  set(msg \"Command failed: \${result}\\n\")
-  foreach(arg IN LISTS command)
-    set(msg \"\${msg} '\${arg}'\")
-  endforeach()
-  execute_process (COMMAND \${CMAKE_COMMAND} -E echo \"Build output for ${logbase} : \")
-  _echo_file (\"${logbase}-out.log\")
-  _echo_file (\"${logbase}-err.log\")
-  set(msg \"\${msg}\\nSee above\\n\")
-  message(FATAL_ERROR \"\${msg}\")
-else()
-  set(msg \"${name} ${step} command succeeded.  See also ${logbase}-*.log\")
-  message(STATUS \"\${msg}\")
-endif()
-")
-  file(GENERATE OUTPUT "${script}" CONTENT "${code}")
-  set(command ${CMAKE_COMMAND} ${make} ${config} -P ${script})
-  set(${cmd_var} "${command}" PARENT_SCOPE)
-endfunction()
-
 find_package(Git)
 
-# function that calls git log to get current hash
-function (git_hash hash_val)
-  # note: optional second extra string argument not in signature
-  if (NOT GIT_FOUND)
-    return ()
-  endif ()
-  set (_hash "")
-  set (_format "%H")
-  if (ARGC GREATER_EQUAL 2)
-    string (TOLOWER ${ARGV1} _short)
-    if (_short STREQUAL "short")
-      set (_format "%h")
-    endif ()
-  endif ()
-  execute_process (COMMAND ${GIT_EXECUTABLE} "log" "--pretty=${_format}" "-n1"
-                   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                   RESULT_VARIABLE _git_exit_code
-                   OUTPUT_VARIABLE _temp_hash
-                   OUTPUT_STRIP_TRAILING_WHITESPACE
-                   ERROR_QUIET)
-  if (_git_exit_code EQUAL 0)
-    set (_hash ${_temp_hash})
-  endif ()
-  set (${hash_val} "${_hash}" PARENT_SCOPE)
-endfunction ()
-
 function (git_branch branch_val)
   if (NOT GIT_FOUND)
     return ()
@@ -204,4 +46,3 @@ function (git_branch branch_val)
   endif ()
   set (${branch_val} "${_branch}" PARENT_SCOPE)
 endfunction ()
-

Builds/CMake/CMake_sqlite3.txt

@@ -1,60 +0,0 @@
-
-#[=========================================================[
-  SQLITE doesn't provide build files in the
-  standard source-only distribution. So we wrote
-  a simple cmake file and we copy it to the
-  external project folder so that we can use
-  this file to build the lib with ExternalProject
-#]=========================================================]
-
-add_library (sqlite3 STATIC sqlite3.c)
-#[=========================================================[
-   When compiled with SQLITE_THREADSAFE=1, SQLite operates
-   in serialized mode. In this mode, SQLite can be safely
-   used by multiple threads with no restriction.
-
-   NOTE: This implies a global mutex!
-
-   When compiled with SQLITE_THREADSAFE=2, SQLite can be
-   used in a multithreaded program so long as no two
-   threads attempt to use the same database connection at
-   the same time.
-
-   NOTE: This is the preferred threading model, but not
-   currently enabled because we need to investigate our
-   use-model and concurrency requirements.
-
-   TODO: consider whether any other options should be
-   used: https://www.sqlite.org/compile.html
-#]=========================================================]
-
-target_compile_definitions (sqlite3
-  PRIVATE
-    SQLITE_THREADSAFE=1
-    HAVE_USLEEP=1)
-target_compile_options (sqlite3
-  PRIVATE
-    $<$<BOOL:${MSVC}>:
-      -wd4100
-      -wd4127
-      -wd4232
-      -wd4244
-      -wd4701
-      -wd4706
-      -wd4996
-    >
-    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-array-bounds>)
-install (
-  TARGETS
-    sqlite3
-  LIBRARY DESTINATION lib
-  ARCHIVE DESTINATION lib
-  RUNTIME DESTINATION bin
-  INCLUDES DESTINATION include)
-install (
-  FILES
-    sqlite3.h
-    sqlite3ext.h
-  DESTINATION include)
-
-

Builds/CMake/CodeCoverage.cmake

@@ -0,0 +1,440 @@
+# Copyright (c) 2012 - 2017, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# CHANGES:
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# 2016-02-03, Lars Bilke
+# - Refactored functions to use named parameters
+#
+# 2017-06-02, Lars Bilke
+# - Merged with modified version from github.com/ufz/ogs
+#
+# 2019-05-06, Anatolii Kurotych
+# - Remove unnecessary --coverage flag
+#
+# 2019-12-13, FeRD (Frank Dana)
+# - Deprecate COVERAGE_LCOVR_EXCLUDES and COVERAGE_GCOVR_EXCLUDES lists in favor
+#   of tool-agnostic COVERAGE_EXCLUDES variable, or EXCLUDE setup arguments.
+# - CMake 3.4+: All excludes can be specified relative to BASE_DIRECTORY
+# - All setup functions: accept BASE_DIRECTORY, EXCLUDE list
+# - Set lcov basedir with -b argument
+# - Add automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be
+#   overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().)
+# - Delete output dir, .info file on 'make clean'
+# - Remove Python detection, since version mismatches will break gcovr
+# - Minor cleanup (lowercase function names, update examples...)
+#
+# 2019-12-19, FeRD (Frank Dana)
+# - Rename Lcov outputs, make filtered file canonical, fix cleanup for targets
+#
+# 2020-01-19, Bob Apthorpe
+# - Added gfortran support
+#
+# 2020-02-17, FeRD (Frank Dana)
+# - Make all add_custom_target()s VERBATIM to auto-escape wildcard characters
+#   in EXCLUDEs, and remove manual escaping from gcovr targets
+#
+# 2021-01-19, Robin Mueller
+# - Add CODE_COVERAGE_VERBOSE option which will allow to print out commands which are run
+# - Added the option for users to set the GCOVR_ADDITIONAL_ARGS variable to supply additional
+#   flags to the gcovr command
+#
+# 2020-05-04, Mihchael Davis
+#     - Add -fprofile-abs-path to make gcno files contain absolute paths
+#     - Fix BASE_DIRECTORY not working when defined
+#     - Change BYPRODUCT from folder to index.html to stop ninja from complaining about double defines
+#
+# 2021-05-10, Martin Stump
+#     - Check if the generator is multi-config before warning about non-Debug builds
+#
+# 2022-02-22, Marko Wehle
+#     - Change gcovr output from -o <filename> for --xml <filename> and --html <filename> output respectively.
+#       This will allow for Multiple Output Formats at the same time by making use of GCOVR_ADDITIONAL_ARGS, e.g. GCOVR_ADDITIONAL_ARGS "--txt".
+#
+# 2022-09-28, Sebastian Mueller
+#     - fix append_coverage_compiler_flags_to_target to correctly add flags
+#     - replace "-fprofile-arcs -ftest-coverage" with "--coverage" (equivalent)
+#
+# 2024-01-04, Bronek Kozicki
+#     - remove setup_target_for_coverage_lcov (slow) and setup_target_for_coverage_fastcov (no support for Clang)
+#     - fix Clang support by adding find_program( ... llvm-cov )
+#     - add Apple Clang support by adding execute_process( COMMAND xcrun -f llvm-cov ... )
+#     - add CODE_COVERAGE_GCOV_TOOL to explicitly select gcov tool and disable find_program
+#     - replace both functions setup_target_for_coverage_gcovr_* with a single setup_target_for_coverage_gcovr
+#     - add support for all gcovr output formats
+#
+# USAGE:
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt (best inside an if-condition
+#    using a CMake option() to enable it just optionally):
+#      include(CodeCoverage)
+#
+# 3. Append necessary compiler flags for all supported source files:
+#      append_coverage_compiler_flags()
+#    Or for specific target:
+#      append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME)
+#
+# 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og
+#
+# 4. If you need to exclude additional directories from the report, specify them
+#    using full paths in the COVERAGE_EXCLUDES variable before calling
+#    setup_target_for_coverage_*().
+#    Example:
+#      set(COVERAGE_EXCLUDES
+#          '${PROJECT_SOURCE_DIR}/src/dir1/*'
+#          '/path/to/my/src/dir2/*')
+#    Or, use the EXCLUDE argument to setup_target_for_coverage_*().
+#    Example:
+#      setup_target_for_coverage_gcovr(
+#          NAME coverage
+#          EXECUTABLE testrunner
+#          EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" "/path/to/my/src/dir2/*")
+#
+# 4.a NOTE: With CMake 3.4+, COVERAGE_EXCLUDES or EXCLUDE can also be set
+#     relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR)
+#     Example:
+#       set(COVERAGE_EXCLUDES "dir1/*")
+#       setup_target_for_coverage_gcovr(
+#           NAME coverage
+#           EXECUTABLE testrunner
+#           FORMAT html-details
+#           BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src"
+#           EXCLUDE "dir2/*")
+#
+# 4.b If you need to pass specific options to gcovr, specify them in
+#     GCOVR_ADDITIONAL_ARGS variable.
+#     Example:
+#       set (GCOVR_ADDITIONAL_ARGS --exclude-throw-branches --exclude-noncode-lines -s)
+#       setup_target_for_coverage_gcovr(
+#           NAME coverage
+#           EXECUTABLE testrunner
+#           EXCLUDE "src/dir1" "src/dir2")
+#
+# 5. Use the functions described below to create a custom make target which
+#    runs your test executable and produces a code coverage report.
+#
+# 6. Build a Debug build:
+#      cmake -DCMAKE_BUILD_TYPE=Debug ..
+#      make
+#      make my_coverage_target
+
+include(CMakeParseArguments)
+
+option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)
+
+# Check prereqs
+find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+
+if(DEFINED CODE_COVERAGE_GCOV_TOOL)
+  set(GCOV_TOOL "${CODE_COVERAGE_GCOV_TOOL}")
+elseif(DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
+  set(GCOV_TOOL "$ENV{CODE_COVERAGE_GCOV_TOOL}")
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+  if(APPLE)
+    execute_process( COMMAND xcrun -f llvm-cov
+      OUTPUT_VARIABLE LLVMCOV_PATH
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+  else()
+    find_program( LLVMCOV_PATH llvm-cov )
+  endif()
+  if(LLVMCOV_PATH)
+    set(GCOV_TOOL "${LLVMCOV_PATH} gcov")
+  endif()
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+  find_program( GCOV_PATH gcov )
+  set(GCOV_TOOL "${GCOV_PATH}")
+endif()
+
+# Check supported compiler (Clang, GNU and Flang)
+get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
+foreach(LANG ${LANGUAGES})
+  if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
+      message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+    endif()
+  elseif(NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU"
+         AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(LLVM)?[Ff]lang")
+    message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
+  endif()
+endforeach()
+
+set(COVERAGE_COMPILER_FLAGS "-g --coverage"
+    CACHE INTERNAL "")
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+    include(CheckCXXCompilerFlag)
+    check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
+    if(HAVE_cxx_fprofile_abs_path)
+        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+    endif()
+    include(CheckCCompilerFlag)
+    check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
+    if(HAVE_c_fprofile_abs_path)
+        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+    endif()
+endif()
+
+set(CMAKE_Fortran_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the Fortran compiler during coverage builds."
+    FORCE )
+set(CMAKE_CXX_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+set(CMAKE_C_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+mark_as_advanced(
+    CMAKE_Fortran_FLAGS_COVERAGE
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
+    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
+endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+    link_libraries(gcov)
+endif()
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_gcovr(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+#     BASE_DIRECTORY "../"                   # Base directory for report
+#                                            #  (defaults to PROJECT_SOURCE_DIR)
+#     FORMAT "cobertura"                     # Output format, one of:
+#                                            #  xml cobertura sonarqube json-summary
+#                                            #  json-details coveralls csv txt
+#                                            #  html-single html-nested html-details
+#                                            #  (xml is an alias to cobertura;
+#                                            #  if no format is set, defaults to xml)
+#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
+#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
+# )
+# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
+# GCVOR command.
+function(setup_target_for_coverage_gcovr)
+    set(options NONE)
+    set(oneValueArgs BASE_DIRECTORY NAME FORMAT)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT GCOV_TOOL)
+        message(FATAL_ERROR "Could not find gcov or llvm-cov tool! Aborting...")
+    endif()
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "Could not find gcovr tool! Aborting...")
+    endif()
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(DEFINED Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    if(NOT DEFINED Coverage_FORMAT)
+        set(Coverage_FORMAT xml)
+    endif()
+
+    if("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
+        message(FATAL_ERROR "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting...")
+    else()
+        if((Coverage_FORMAT STREQUAL "html-details")
+            OR (Coverage_FORMAT STREQUAL "html-nested"))
+            set(GCOVR_OUTPUT_FILE ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html)
+            set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
+        elseif(Coverage_FORMAT STREQUAL "html-single")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
+        elseif((Coverage_FORMAT STREQUAL "json-summary")
+            OR (Coverage_FORMAT STREQUAL "json-details")
+            OR (Coverage_FORMAT STREQUAL "coveralls"))
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
+        elseif(Coverage_FORMAT STREQUAL "txt")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
+        elseif(Coverage_FORMAT STREQUAL "csv")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
+        else()
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
+        endif()
+    endif()
+
+    if((Coverage_FORMAT STREQUAL "cobertura")
+        OR (Coverage_FORMAT STREQUAL "xml"))
+        list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura-pretty )
+        set(Coverage_FORMAT cobertura) # overwrite xml
+    elseif(Coverage_FORMAT STREQUAL "sonarqube")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "json-summary")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)
+    elseif(Coverage_FORMAT STREQUAL "json-details")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json-pretty)
+    elseif(Coverage_FORMAT STREQUAL "coveralls")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls-pretty)
+    elseif(Coverage_FORMAT STREQUAL "csv")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --csv "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "txt")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --txt "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "html-single")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --html "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --html-self-contained)
+    elseif(Coverage_FORMAT STREQUAL "html-nested")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --html-nested "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "html-details")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --html-details "${GCOVR_OUTPUT_FILE}" )
+    else()
+        message(FATAL_ERROR "Unsupported output style ${Coverage_FORMAT}! Aborting...")
+    endif()
+
+    # Collect excludes (CMake 3.4+: Also compute absolute paths)
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+        endif()
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDE_ARGS "")
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
+        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
+    endforeach()
+
+    # Set up commands which will be run to generate coverage data
+    # Run tests
+    set(GCOVR_EXEC_TESTS_CMD
+        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    )
+
+    # Create folder
+    if(DEFINED GCOVR_CREATE_FOLDER)
+        set(GCOVR_FOLDER_CMD
+            ${CMAKE_COMMAND} -E make_directory ${GCOVR_CREATE_FOLDER})
+    else()
+        set(GCOVR_FOLDER_CMD echo) # dummy
+    endif()
+
+    # Running gcovr
+    set(GCOVR_CMD
+        ${GCOVR_PATH}
+        --gcov-executable ${GCOV_TOOL}
+        --gcov-ignore-parse-errors=negative_hits.warn_once_per_file
+        -r ${BASEDIR}
+        ${GCOVR_ADDITIONAL_ARGS}
+        ${GCOVR_EXCLUDE_ARGS}
+        --object-directory=${PROJECT_BINARY_DIR}
+    )
+
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Executed command report")
+
+        message(STATUS "Command to run tests: ")
+        string(REPLACE ";" " " GCOVR_EXEC_TESTS_CMD_SPACED "${GCOVR_EXEC_TESTS_CMD}")
+        message(STATUS "${GCOVR_EXEC_TESTS_CMD_SPACED}")
+
+        if(NOT GCOVR_FOLDER_CMD STREQUAL "echo")
+            message(STATUS "Command to create a folder: ")
+            string(REPLACE ";" " " GCOVR_FOLDER_CMD_SPACED "${GCOVR_FOLDER_CMD}")
+            message(STATUS "${GCOVR_FOLDER_CMD_SPACED}")
+        endif()
+
+        message(STATUS "Command to generate gcovr coverage data: ")
+        string(REPLACE ";" " " GCOVR_CMD_SPACED "${GCOVR_CMD}")
+        message(STATUS "${GCOVR_CMD_SPACED}")
+    endif()
+
+    add_custom_target(${Coverage_NAME}
+        COMMAND ${GCOVR_EXEC_TESTS_CMD}
+        COMMAND ${GCOVR_FOLDER_CMD}
+        COMMAND ${GCOVR_CMD}
+
+        BYPRODUCTS ${GCOVR_OUTPUT_FILE}
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Running gcovr to produce code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
+    )
+endfunction() # setup_target_for_coverage_gcovr
+
+function(append_coverage_compiler_flags)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
+endfunction() # append_coverage_compiler_flags
+
+# Setup coverage for specific library
+function(append_coverage_compiler_flags_to_target name)
+    separate_arguments(_flag_list NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}")
+    target_compile_options(${name} PRIVATE ${_flag_list})
+    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+        target_link_libraries(${name} PRIVATE gcov)
+    endif()
+endfunction()

Builds/CMake/FindRocksDB.cmake

@@ -0,0 +1,62 @@
+set (RocksDB_DIR "" CACHE PATH "Root directory of RocksDB distribution")
+
+find_path (RocksDB_INCLUDE_DIR
+    rocksdb/db.h
+    PATHS ${RocksDB_DIR})
+
+set (RocksDB_VERSION "")
+find_file (RocksDB_VERSION_FILE
+    rocksdb/version.h
+    PATHS ${RocksDB_DIR})
+if (RocksDB_VERSION_FILE)
+    file (READ ${RocksDB_VERSION_FILE} _verfile)
+    if ("${_verfile}" MATCHES "#define[ \\t]+ROCKSDB_MAJOR[ \\t]+([0-9]+)")
+        string (APPEND RocksDB_VERSION "${CMAKE_MATCH_1}")
+    else ()
+        string (APPEND RocksDB_VERSION "0")
+    endif()
+    if ("${_verfile}" MATCHES "#define[ \\t]+ROCKSDB_MINOR[ \\t]+([0-9]+)")
+        string (APPEND RocksDB_VERSION ".${CMAKE_MATCH_1}")
+    else ()
+        string (APPEND RocksDB_VERSION ".0")
+    endif()
+    if ("${_verfile}" MATCHES "#define[ \\t]+ROCKSDB_PATCH[ \\t]+([0-9]+)")
+        string (APPEND RocksDB_VERSION ".${CMAKE_MATCH_1}")
+    else ()
+        string (APPEND RocksDB_VERSION ".0")
+    endif()
+endif ()
+
+if (RocksDB_USE_STATIC)
+    list (APPEND RocksDB_NAMES
+        "${CMAKE_STATIC_LIBRARY_PREFIX}rocksdb${CMAKE_STATIC_LIBRARY_SUFFIX}"
+        "${CMAKE_STATIC_LIBRARY_PREFIX}rocksdblib${CMAKE_STATIC_LIBRARY_SUFFIX}")
+endif ()
+
+list (APPEND RocksDB_NAMES rocksdb)
+
+find_library (RocksDB_LIBRARY NAMES ${RocksDB_NAMES}
+    PATHS
+    ${RocksDB_DIR}
+    ${RocksDB_DIR}/bin/Release
+    ${RocksDB_DIR}/bin64_vs2013/Release
+    PATH_SUFFIXES lib lib64)
+
+foreach (_n RocksDB_NAMES)
+    list (APPEND RocksDB_NAMES_DBG "${_n}_d" "${_n}d")
+endforeach ()
+find_library (RocksDB_LIBRARY_DEBUG NAMES ${RocksDB_NAMES_DBG}
+    PATHS
+    ${RocksDB_DIR}
+    ${RocksDB_DIR}/bin/Debug
+    ${RocksDB_DIR}/bin64_vs2013/Debug
+    PATH_SUFFIXES lib lib64)
+
+include (FindPackageHandleStandardArgs)
+find_package_handle_standard_args (RocksDB
+    REQUIRED_VARS RocksDB_LIBRARY RocksDB_INCLUDE_DIR
+    VERSION_VAR RocksDB_VERSION)
+
+mark_as_advanced (RocksDB_INCLUDE_DIR RocksDB_LIBRARY)
+set (RocksDB_INCLUDE_DIRS ${RocksDB_INCLUDE_DIR})
+set (RocksDB_LIBRARIES ${RocksDB_LIBRARY})

Builds/CMake/README.md

@@ -0,0 +1,18 @@
+
+These are modules and sources that support our CMake build.
+
+== FindBoost.cmake ==
+
+In order to facilitate updating to latest releases of boost, we've made a local
+copy of the FindBoost cmake module in our repo. The latest official version can
+generally be obtained
+[here](https://github.com/Kitware/CMake/blob/master/Modules/FindBoost.cmake).
+
+The latest version provided by Kitware can be tailored for use with the
+version of CMake that it ships with (typically the next upcoming CMake
+release). As such, the latest version from the repository might not work
+perfectly with older versions of CMake - for instance, the latest version 
+might use features or properties only available in the version of CMake that 
+it ships with. Given this, it's best to test any updates to this module with a few 
+different versions of cmake.
+

Builds/CMake/RippledCompiler.cmake

@@ -130,7 +130,16 @@ else ()
       >)
 endif ()
 
-if (use_gold AND is_gcc)
+if (use_mold)
+  # use mold linker if available
+  execute_process (
+    COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version
+    ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+  if ("${LD_VERSION}" MATCHES "mold")
+    target_link_libraries (common INTERFACE -fuse-ld=mold)
+  endif ()
+  unset (LD_VERSION)
+elseif (use_gold AND is_gcc)
   # use gold linker if available
   execute_process (
     COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
@@ -162,9 +171,7 @@ if (use_gold AND is_gcc)
         $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
   endif ()
   unset (LD_VERSION)
-endif ()
-
-if (use_lld)
+elseif (use_lld)
   # use lld linker if available
   execute_process (
     COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
@@ -175,6 +182,7 @@ if (use_lld)
   unset (LD_VERSION)
 endif()
 
+
 if (assert)
   foreach (var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
     STRING (REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")

Builds/CMake/RippledCore.cmake

@@ -3,9 +3,53 @@
    core functionality, useable by some client software perhaps
 #]===================================================================]
 
+include(target_protobuf_sources)
+
 file (GLOB_RECURSE rb_headers
-  src/ripple/beast/*.h
-  src/ripple/beast/*.hpp)
+  src/ripple/beast/*.h)
+
+# Protocol buffers cannot participate in a unity build,
+# because all the generated sources
+# define a bunch of `static const` variables with the same names,
+# so we just build them as a separate library.
+add_library(xrpl.libpb)
+target_protobuf_sources(xrpl.libpb ripple/proto
+  LANGUAGE cpp
+  IMPORT_DIRS src/ripple/proto
+  PROTOS src/ripple/proto/ripple.proto
+)
+
+file(GLOB_RECURSE protos "src/ripple/proto/org/*.proto")
+target_protobuf_sources(xrpl.libpb ripple/proto
+  LANGUAGE cpp
+  IMPORT_DIRS src/ripple/proto
+  PROTOS "${protos}"
+)
+target_protobuf_sources(xrpl.libpb ripple/proto
+  LANGUAGE grpc
+  IMPORT_DIRS src/ripple/proto
+  PROTOS "${protos}"
+  PLUGIN protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
+  GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc
+)
+
+target_compile_options(xrpl.libpb
+  PUBLIC
+    $<$<BOOL:${MSVC}>:-wd4996>
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >
+  PRIVATE
+    $<$<BOOL:${MSVC}>:-wd4065>
+    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
+)
+
+target_link_libraries(xrpl.libpb
+  PUBLIC
+    protobuf::libprotobuf
+    gRPC::grpc++
+)
 
 add_library (xrpl_core
   ${rb_headers}) ## headers added here for benefit of IDEs
@@ -23,15 +67,19 @@ else()
   message(STATUS "ACL not found, continuing without ACL support")
 endif()
 
+add_library(libxrpl INTERFACE)
+target_link_libraries(libxrpl INTERFACE xrpl_core)
+add_library(xrpl::libxrpl ALIAS libxrpl)
+
 #[===============================[
     beast/legacy FILES:
     TODO: review these sources for removal or replacement
 #]===============================]
+# BEGIN LIBXRPL SOURCES
 target_sources (xrpl_core PRIVATE
   src/ripple/beast/clock/basic_seconds_clock.cpp
   src/ripple/beast/core/CurrentThreadName.cpp
   src/ripple/beast/core/SemanticVersion.cpp
-  src/ripple/beast/hash/impl/xxhash.cpp
   src/ripple/beast/insight/impl/Collector.cpp
   src/ripple/beast/insight/impl/Groups.cpp
   src/ripple/beast/insight/impl/Hook.cpp
@@ -51,16 +99,23 @@ target_sources (xrpl_core PRIVATE
 target_sources (xrpl_core PRIVATE
   #[===============================[
     main sources:
-      subdir: basics (partial)
+      subdir: basics
   #]===============================]
+  src/ripple/basics/impl/Archive.cpp
   src/ripple/basics/impl/base64.cpp
+  src/ripple/basics/impl/BasicConfig.cpp
   src/ripple/basics/impl/contract.cpp
   src/ripple/basics/impl/CountedObject.cpp
   src/ripple/basics/impl/FileUtilities.cpp
   src/ripple/basics/impl/IOUAmount.cpp
   src/ripple/basics/impl/Log.cpp
+  src/ripple/basics/impl/make_SSLContext.cpp
+  src/ripple/basics/impl/mulDiv.cpp
   src/ripple/basics/impl/Number.cpp
+  src/ripple/basics/impl/partitioned_unordered_map.cpp
+  src/ripple/basics/impl/ResolverAsio.cpp
   src/ripple/basics/impl/StringUtilities.cpp
+  src/ripple/basics/impl/UptimeClock.cpp
   #[===============================[
     main sources:
       subdir: json
@@ -79,6 +134,7 @@ target_sources (xrpl_core PRIVATE
       subdir: protocol
   #]===============================]
   src/ripple/protocol/impl/AccountID.cpp
+  src/ripple/protocol/impl/AMMCore.cpp
   src/ripple/protocol/impl/Book.cpp
   src/ripple/protocol/impl/BuildInfo.cpp
   src/ripple/protocol/impl/ErrorCodes.cpp
@@ -86,10 +142,14 @@ target_sources (xrpl_core PRIVATE
   src/ripple/protocol/impl/Indexes.cpp
   src/ripple/protocol/impl/InnerObjectFormats.cpp
   src/ripple/protocol/impl/Issue.cpp
+  src/ripple/protocol/impl/STIssue.cpp
   src/ripple/protocol/impl/Keylet.cpp
   src/ripple/protocol/impl/LedgerFormats.cpp
+  src/ripple/protocol/impl/LedgerHeader.cpp
   src/ripple/protocol/impl/PublicKey.cpp
   src/ripple/protocol/impl/Quality.cpp
+  src/ripple/protocol/impl/QualityFunction.cpp
+  src/ripple/protocol/impl/RPCErr.cpp
   src/ripple/protocol/impl/Rate2.cpp
   src/ripple/protocol/impl/Rules.cpp
   src/ripple/protocol/impl/SField.cpp
@@ -99,12 +159,15 @@ target_sources (xrpl_core PRIVATE
   src/ripple/protocol/impl/STArray.cpp
   src/ripple/protocol/impl/STBase.cpp
   src/ripple/protocol/impl/STBlob.cpp
+  src/ripple/protocol/impl/STCurrency.cpp
   src/ripple/protocol/impl/STInteger.cpp
   src/ripple/protocol/impl/STLedgerEntry.cpp
   src/ripple/protocol/impl/STObject.cpp
   src/ripple/protocol/impl/STParsedJSON.cpp
   src/ripple/protocol/impl/STPathSet.cpp
+  src/ripple/protocol/impl/STXChainBridge.cpp
   src/ripple/protocol/impl/STTx.cpp
+  src/ripple/protocol/impl/XChainAttestations.cpp
   src/ripple/protocol/impl/STValidation.cpp
   src/ripple/protocol/impl/STVar.cpp
   src/ripple/protocol/impl/STVector256.cpp
@@ -118,6 +181,23 @@ target_sources (xrpl_core PRIVATE
   src/ripple/protocol/impl/UintTypes.cpp
   src/ripple/protocol/impl/digest.cpp
   src/ripple/protocol/impl/tokens.cpp
+  src/ripple/protocol/impl/NFTSyntheticSerializer.cpp
+  src/ripple/protocol/impl/NFTokenID.cpp
+  src/ripple/protocol/impl/NFTokenOfferID.cpp
+  #[===============================[
+     main sources:
+       subdir: resource
+  #]===============================]
+  src/ripple/resource/impl/Charge.cpp
+  src/ripple/resource/impl/Consumer.cpp
+  src/ripple/resource/impl/Fees.cpp
+  src/ripple/resource/impl/ResourceManager.cpp
+  #[===============================[
+     main sources:
+       subdir: server
+  #]===============================]
+  src/ripple/server/impl/JSONRPCUtil.cpp
+  src/ripple/server/impl/Port.cpp
   #[===============================[
     main sources:
       subdir: crypto
@@ -125,6 +205,7 @@ target_sources (xrpl_core PRIVATE
   src/ripple/crypto/impl/RFC1751.cpp
   src/ripple/crypto/impl/csprng.cpp
   src/ripple/crypto/impl/secure_erase.cpp)
+# END LIBXRPL SOURCES
 
 add_library (Ripple::xrpl_core ALIAS xrpl_core)
 target_include_directories (xrpl_core
@@ -142,44 +223,71 @@ target_compile_options (xrpl_core
     $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>)
 target_link_libraries (xrpl_core
   PUBLIC
+    date::date
+    ed25519::ed25519
+    LibArchive::LibArchive
     OpenSSL::Crypto
     Ripple::boost
     wasmedge::wasmedge
+    Ripple::opts
     Ripple::syslibs
     secp256k1::secp256k1
-    ed25519::ed25519
-    date::date
-    Ripple::opts)
+    xrpl.libpb
+    xxHash::xxhash)
 #[=================================[
    main/core headers installation
 #]=================================]
+# BEGIN LIBXRPL HEADERS
 install (
   FILES
-    src/ripple/basics/base64.h
+    src/ripple/basics/Archive.h
+    src/ripple/basics/BasicConfig.h
     src/ripple/basics/Blob.h
     src/ripple/basics/Buffer.h
+    src/ripple/basics/ByteUtilities.h
+    src/ripple/basics/CompressionAlgorithms.h
     src/ripple/basics/CountedObject.h
+    src/ripple/basics/DecayingSample.h
+    src/ripple/basics/Expected.h
+    src/ripple/basics/FeeUnits.h
     src/ripple/basics/FileUtilities.h
     src/ripple/basics/IOUAmount.h
+    src/ripple/basics/KeyCache.h
     src/ripple/basics/LocalValue.h
     src/ripple/basics/Log.h
     src/ripple/basics/MathUtilities.h
     src/ripple/basics/Number.h
-    src/ripple/basics/safe_cast.h
+    src/ripple/basics/PerfLog.h
+    src/ripple/basics/README.md
+    src/ripple/basics/RangeSet.h
+    src/ripple/basics/Resolver.h
+    src/ripple/basics/ResolverAsio.h
+    src/ripple/basics/SHAMapHash.h
     src/ripple/basics/Slice.h
-    src/ripple/basics/spinlock.h
     src/ripple/basics/StringUtilities.h
+    src/ripple/basics/TaggedCache.h
     src/ripple/basics/ThreadSafetyAnalysis.h
     src/ripple/basics/ToString.h
     src/ripple/basics/UnorderedContainers.h
+    src/ripple/basics/UptimeClock.h
     src/ripple/basics/XRPAmount.h
     src/ripple/basics/algorithm.h
+    src/ripple/basics/base64.h
     src/ripple/basics/base_uint.h
     src/ripple/basics/chrono.h
+    src/ripple/basics/comparators.h
     src/ripple/basics/contract.h
-    src/ripple/basics/FeeUnits.h
     src/ripple/basics/hardened_hash.h
+    src/ripple/basics/join.h
+    src/ripple/basics/make_SSLContext.h
+    src/ripple/basics/mulDiv.h
+    src/ripple/basics/partitioned_unordered_map.h
+    src/ripple/basics/random.h
+    src/ripple/basics/safe_cast.h
+    src/ripple/basics/scope.h
+    src/ripple/basics/spinlock.h
     src/ripple/basics/strHex.h
+    src/ripple/basics/tagged_integer.h
   DESTINATION include/ripple/basics)
 install (
   FILES
@@ -206,25 +314,42 @@ install (
 install (
   FILES
     src/ripple/protocol/AccountID.h
+    src/ripple/protocol/AMMCore.h
     src/ripple/protocol/AmountConversions.h
+    src/ripple/protocol/ApiVersion.h
     src/ripple/protocol/Book.h
     src/ripple/protocol/BuildInfo.h
     src/ripple/protocol/ErrorCodes.h
     src/ripple/protocol/Feature.h
+    src/ripple/protocol/Fees.h
     src/ripple/protocol/HashPrefix.h
     src/ripple/protocol/Indexes.h
     src/ripple/protocol/InnerObjectFormats.h
     src/ripple/protocol/Issue.h
-    src/ripple/protocol/KeyType.h
+    src/ripple/protocol/json_get_or_throw.h
     src/ripple/protocol/Keylet.h
+    src/ripple/protocol/KeyType.h
     src/ripple/protocol/KnownFormats.h
     src/ripple/protocol/LedgerFormats.h
+    src/ripple/protocol/LedgerHeader.h
+    src/ripple/protocol/MultiApiJson.h
+    src/ripple/protocol/NFTSyntheticSerializer.h
+    src/ripple/protocol/NFTokenID.h
+    src/ripple/protocol/NFTokenOfferID.h
+    src/ripple/protocol/NFTSyntheticSerializer.h
     src/ripple/protocol/Protocol.h
     src/ripple/protocol/PublicKey.h
     src/ripple/protocol/Quality.h
+    src/ripple/protocol/QualityFunction.h
     src/ripple/protocol/Rate.h
+    src/ripple/protocol/RPCErr.h
     src/ripple/protocol/Rules.h
+    src/ripple/protocol/SecretKey.h
+    src/ripple/protocol/Seed.h
+    src/ripple/protocol/SeqProxy.h
+    src/ripple/protocol/Serializer.h
     src/ripple/protocol/SField.h
+    src/ripple/protocol/Sign.h
     src/ripple/protocol/SOTemplate.h
     src/ripple/protocol/STAccount.h
     src/ripple/protocol/STAmount.h
@@ -232,8 +357,10 @@ install (
     src/ripple/protocol/STBase.h
     src/ripple/protocol/STBitString.h
     src/ripple/protocol/STBlob.h
+    src/ripple/protocol/STCurrency.h
     src/ripple/protocol/STExchange.h
     src/ripple/protocol/STInteger.h
+    src/ripple/protocol/STIssue.h
     src/ripple/protocol/STLedgerEntry.h
     src/ripple/protocol/STObject.h
     src/ripple/protocol/STParsedJSON.h
@@ -241,27 +368,72 @@ install (
     src/ripple/protocol/STTx.h
     src/ripple/protocol/STValidation.h
     src/ripple/protocol/STVector256.h
-    src/ripple/protocol/SecretKey.h
-    src/ripple/protocol/Seed.h
-    src/ripple/protocol/SeqProxy.h
-    src/ripple/protocol/Serializer.h
-    src/ripple/protocol/Sign.h
+    src/ripple/protocol/STXChainBridge.h
     src/ripple/protocol/SystemParameters.h
     src/ripple/protocol/TER.h
     src/ripple/protocol/TxFlags.h
     src/ripple/protocol/TxFormats.h
     src/ripple/protocol/TxMeta.h
     src/ripple/protocol/UintTypes.h
+    src/ripple/protocol/XChainAttestations.h
     src/ripple/protocol/digest.h
     src/ripple/protocol/jss.h
+    src/ripple/protocol/nft.h
+    src/ripple/protocol/nftPageMask.h
+    src/ripple/protocol/serialize.h
     src/ripple/protocol/tokens.h
   DESTINATION include/ripple/protocol)
 install (
   FILES
-    src/ripple/protocol/impl/STVar.h
+  src/ripple/protocol/impl/STVar.h
+    src/ripple/protocol/impl/b58_utils.h
     src/ripple/protocol/impl/secp256k1.h
+    src/ripple/protocol/impl/token_errors.h
   DESTINATION include/ripple/protocol/impl)
-
+install (
+  FILES
+    src/ripple/resource/Charge.h
+    src/ripple/resource/Consumer.h
+    src/ripple/resource/Disposition.h
+    src/ripple/resource/Fees.h
+    src/ripple/resource/Gossip.h
+    src/ripple/resource/ResourceManager.h
+    src/ripple/resource/Types.h
+  DESTINATION include/ripple/resource)
+install (
+  FILES
+    src/ripple/resource/impl/Entry.h
+    src/ripple/resource/impl/Import.h
+    src/ripple/resource/impl/Key.h
+    src/ripple/resource/impl/Kind.h
+    src/ripple/resource/impl/Logic.h
+    src/ripple/resource/impl/Tuning.h
+  DESTINATION include/ripple/resource/impl)
+install (
+  FILES
+    src/ripple/server/Handoff.h
+    src/ripple/server/Port.h
+    src/ripple/server/Server.h
+    src/ripple/server/Session.h
+    src/ripple/server/SimpleWriter.h
+    src/ripple/server/Writer.h
+    src/ripple/server/WSSession.h
+  DESTINATION include/ripple/server)
+install (
+  FILES
+    src/ripple/server/impl/BaseHTTPPeer.h
+    src/ripple/server/impl/BasePeer.h
+    src/ripple/server/impl/BaseWSPeer.h
+    src/ripple/server/impl/Door.h
+    src/ripple/server/impl/JSONRPCUtil.h
+    src/ripple/server/impl/LowestLayer.h
+    src/ripple/server/impl/PlainHTTPPeer.h
+    src/ripple/server/impl/PlainWSPeer.h
+    src/ripple/server/impl/ServerImpl.h
+    src/ripple/server/impl/SSLHTTPPeer.h
+    src/ripple/server/impl/SSLWSPeer.h
+    src/ripple/server/impl/io_list.h
+  DESTINATION include/ripple/server/impl)
 #[===================================[
    beast/legacy headers installation
 #]===================================]
@@ -273,6 +445,7 @@ install (
   DESTINATION include/ripple/beast/clock)
 install (
   FILES
+    src/ripple/beast/core/CurrentThreadName.h
     src/ripple/beast/core/LexicalCast.h
     src/ripple/beast/core/List.h
     src/ripple/beast/core/SemanticVersion.h
@@ -284,8 +457,13 @@ install (
     src/ripple/beast/hash/xxhasher.h
   DESTINATION include/ripple/beast/hash)
 install (
-  FILES src/ripple/beast/hash/impl/xxhash.h
-  DESTINATION include/ripple/beast/hash/impl)
+  FILES
+    src/ripple/beast/net/IPAddress.h
+    src/ripple/beast/net/IPAddressConversion.h
+    src/ripple/beast/net/IPAddressV4.h
+    src/ripple/beast/net/IPAddressV6.h
+    src/ripple/beast/net/IPEndpoint.h
+  DESTINATION include/ripple/beast/net)
 install (
   FILES
     src/ripple/beast/rfc2616.h
@@ -293,37 +471,34 @@ install (
     src/ripple/beast/unit_test.h
     src/ripple/beast/xor_shift_engine.h
   DESTINATION include/ripple/beast)
+install (
+  FILES
+    src/ripple/beast/unit_test/amount.h
+    src/ripple/beast/unit_test/dstream.h
+    src/ripple/beast/unit_test/global_suites.h
+    src/ripple/beast/unit_test/match.h
+    src/ripple/beast/unit_test/recorder.h
+    src/ripple/beast/unit_test/reporter.h
+    src/ripple/beast/unit_test/results.h
+    src/ripple/beast/unit_test/runner.h
+    src/ripple/beast/unit_test/suite_info.h
+    src/ripple/beast/unit_test/suite_list.h
+    src/ripple/beast/unit_test/suite.h
+    src/ripple/beast/unit_test/thread.h
+  DESTINATION include/ripple/beast/unit_test)
+install (
+  FILES
+    src/ripple/beast/unit_test/detail/const_container.h
+  DESTINATION include/ripple/beast/unit_test/detail)
 install (
   FILES
     src/ripple/beast/utility/Journal.h
     src/ripple/beast/utility/PropertyStream.h
+    src/ripple/beast/utility/WrappedSink.h
     src/ripple/beast/utility/Zero.h
     src/ripple/beast/utility/rngfill.h
   DESTINATION include/ripple/beast/utility)
-# WARNING!! -- horrible levelization ahead
-# (these files should be isolated or moved...but
-#  unfortunately unit_test.h above creates this dependency)
-if (tests)
-  install (
-    FILES
-      src/ripple/beast/unit_test/amount.hpp
-      src/ripple/beast/unit_test/dstream.hpp
-      src/ripple/beast/unit_test/global_suites.hpp
-      src/ripple/beast/unit_test/match.hpp
-      src/ripple/beast/unit_test/recorder.hpp
-      src/ripple/beast/unit_test/reporter.hpp
-      src/ripple/beast/unit_test/results.hpp
-      src/ripple/beast/unit_test/runner.hpp
-      src/ripple/beast/unit_test/suite.hpp
-      src/ripple/beast/unit_test/suite_info.hpp
-      src/ripple/beast/unit_test/suite_list.hpp
-      src/ripple/beast/unit_test/thread.hpp
-    DESTINATION include/ripple/beast/extras/unit_test)
-  install (
-    FILES
-      src/ripple/beast/unit_test/detail/const_container.hpp
-    DESTINATION include/ripple/beast/unit_test/detail)
-endif () #tests
+# END LIBXRPL HEADERS
 #[===================================================================[
    rippled executable
 #]===================================================================]
@@ -340,6 +515,7 @@ endif ()
 if (tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
 endif()
+# BEGIN XRPLD SOURCES
 target_sources (rippled PRIVATE
   #[===============================[
      main sources:
@@ -386,15 +562,19 @@ target_sources (rippled PRIVATE
   src/ripple/app/reporting/ReportingETL.cpp
   src/ripple/app/reporting/ETLSource.cpp
   src/ripple/app/reporting/P2pProxy.cpp
+  src/ripple/app/misc/impl/AMMHelpers.cpp
+  src/ripple/app/misc/impl/AMMUtils.cpp
   src/ripple/app/misc/CanonicalTXSet.cpp
   src/ripple/app/misc/FeeVoteImpl.cpp
   src/ripple/app/misc/HashRouter.cpp
   src/ripple/app/misc/NegativeUNLVote.cpp
   src/ripple/app/misc/NetworkOPs.cpp
   src/ripple/app/misc/SHAMapStoreImp.cpp
+  src/ripple/app/misc/StateAccounting.cpp
   src/ripple/app/misc/detail/impl/WorkSSL.cpp
   src/ripple/app/misc/impl/AccountTxPaging.cpp
   src/ripple/app/misc/impl/AmendmentTable.cpp
+  src/ripple/app/misc/impl/DeliverMax.cpp
   src/ripple/app/misc/impl/LoadFeeTrack.cpp
   src/ripple/app/misc/impl/Manifest.cpp
   src/ripple/app/misc/impl/Transaction.cpp
@@ -411,6 +591,8 @@ target_sources (rippled PRIVATE
   src/ripple/app/paths/RippleCalc.cpp
   src/ripple/app/paths/RippleLineCache.cpp
   src/ripple/app/paths/TrustLine.cpp
+  src/ripple/app/paths/impl/AMMLiquidity.cpp
+  src/ripple/app/paths/impl/AMMOffer.cpp
   src/ripple/app/paths/impl/BookStep.cpp
   src/ripple/app/paths/impl/DirectStep.cpp
   src/ripple/app/paths/impl/PaySteps.cpp
@@ -427,6 +609,12 @@ target_sources (rippled PRIVATE
   src/ripple/app/rdb/impl/UnitaryShard.cpp
   src/ripple/app/rdb/impl/Vacuum.cpp
   src/ripple/app/rdb/impl/Wallet.cpp
+  src/ripple/app/tx/impl/AMMBid.cpp
+  src/ripple/app/tx/impl/AMMCreate.cpp
+  src/ripple/app/tx/impl/AMMDelete.cpp
+  src/ripple/app/tx/impl/AMMDeposit.cpp
+  src/ripple/app/tx/impl/AMMVote.cpp
+  src/ripple/app/tx/impl/AMMWithdraw.cpp
   src/ripple/app/tx/impl/ApplyContext.cpp
   src/ripple/app/tx/impl/BookTip.cpp
   src/ripple/app/tx/impl/CancelCheck.cpp
@@ -434,11 +622,14 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/CashCheck.cpp
   src/ripple/app/tx/impl/Change.cpp
   src/ripple/app/tx/impl/ClaimReward.cpp
+  src/ripple/app/tx/impl/Clawback.cpp
   src/ripple/app/tx/impl/CreateCheck.cpp
   src/ripple/app/tx/impl/CreateOffer.cpp
   src/ripple/app/tx/impl/CreateTicket.cpp
   src/ripple/app/tx/impl/DeleteAccount.cpp
+  src/ripple/app/tx/impl/DeleteOracle.cpp
   src/ripple/app/tx/impl/DepositPreauth.cpp
+  src/ripple/app/tx/impl/DID.cpp
   src/ripple/app/tx/impl/Escrow.cpp
   src/ripple/app/tx/impl/GenesisMint.cpp
   src/ripple/app/tx/impl/Import.cpp
@@ -455,9 +646,12 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/Remit.cpp
   src/ripple/app/tx/impl/SetAccount.cpp
   src/ripple/app/tx/impl/SetHook.cpp
+  src/ripple/app/tx/impl/SetOracle.cpp
+  src/ripple/app/tx/impl/SetRemarks.cpp
   src/ripple/app/tx/impl/SetRegularKey.cpp
   src/ripple/app/tx/impl/SetSignerList.cpp
   src/ripple/app/tx/impl/SetTrust.cpp
+  src/ripple/app/tx/impl/XChainBridge.cpp
   src/ripple/app/tx/impl/SignerEntries.cpp
   src/ripple/app/tx/impl/Taker.cpp
   src/ripple/app/tx/impl/Transactor.cpp
@@ -466,17 +660,6 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/applySteps.cpp
   src/ripple/app/hook/impl/applyHook.cpp
   src/ripple/app/tx/impl/details/NFTokenUtils.cpp
-  #[===============================[
-     main sources:
-       subdir: basics (partial)
-  #]===============================]
-  src/ripple/basics/impl/Archive.cpp
-  src/ripple/basics/impl/BasicConfig.cpp
-  src/ripple/basics/impl/ResolverAsio.cpp
-  src/ripple/basics/impl/UptimeClock.cpp
-  src/ripple/basics/impl/make_SSLContext.cpp
-  src/ripple/basics/impl/mulDiv.cpp
-  src/ripple/basics/impl/partitioned_unordered_map.cpp
   #[===============================[
      main sources:
        subdir: conditions
@@ -494,9 +677,7 @@ target_sources (rippled PRIVATE
   src/ripple/core/impl/JobQueue.cpp
   src/ripple/core/impl/LoadEvent.cpp
   src/ripple/core/impl/LoadMonitor.cpp
-  src/ripple/core/impl/SNTPClock.cpp
   src/ripple/core/impl/SociDB.cpp
-  src/ripple/core/impl/TimeKeeper.cpp
   src/ripple/core/impl/Workers.cpp
   src/ripple/core/Pg.cpp
   #[===============================[
@@ -530,7 +711,6 @@ target_sources (rippled PRIVATE
   src/ripple/net/impl/HTTPStream.cpp
   src/ripple/net/impl/InfoSub.cpp
   src/ripple/net/impl/RPCCall.cpp
-  src/ripple/net/impl/RPCErr.cpp
   src/ripple/net/impl/RPCSub.cpp
   src/ripple/net/impl/RegisterSSLCerts.cpp
   #[===============================[
@@ -538,7 +718,9 @@ target_sources (rippled PRIVATE
        subdir: nodestore
   #]===============================]
   src/ripple/nodestore/backend/CassandraFactory.cpp
+  src/ripple/nodestore/backend/RWDBFactory.cpp
   src/ripple/nodestore/backend/MemoryFactory.cpp
+  src/ripple/nodestore/backend/FlatmapFactory.cpp
   src/ripple/nodestore/backend/NuDBFactory.cpp
   src/ripple/nodestore/backend/NullFactory.cpp
   src/ripple/nodestore/backend/RocksDBFactory.cpp
@@ -580,14 +762,6 @@ target_sources (rippled PRIVATE
   src/ripple/peerfinder/impl/PeerfinderManager.cpp
   src/ripple/peerfinder/impl/SlotImp.cpp
   src/ripple/peerfinder/impl/SourceStrings.cpp
-  #[===============================[
-     main sources:
-       subdir: resource
-  #]===============================]
-  src/ripple/resource/impl/Charge.cpp
-  src/ripple/resource/impl/Consumer.cpp
-  src/ripple/resource/impl/Fees.cpp
-  src/ripple/resource/impl/ResourceManager.cpp
   #[===============================[
      main sources:
        subdir: rpc
@@ -600,9 +774,11 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/handlers/AccountOffers.cpp
   src/ripple/rpc/handlers/AccountNamespace.cpp
   src/ripple/rpc/handlers/AccountTx.cpp
+  src/ripple/rpc/handlers/AMMInfo.cpp
   src/ripple/rpc/handlers/BlackList.cpp
   src/ripple/rpc/handlers/BookOffers.cpp
   src/ripple/rpc/handlers/CanDelete.cpp
+  src/ripple/rpc/handlers/Catalogue.cpp
   src/ripple/rpc/handlers/Connect.cpp
   src/ripple/rpc/handlers/ConsensusInfo.cpp
   src/ripple/rpc/handlers/CrawlShards.cpp
@@ -613,6 +789,7 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/handlers/FetchInfo.cpp
   src/ripple/rpc/handlers/GatewayBalances.cpp
   src/ripple/rpc/handlers/GetCounts.cpp
+  src/ripple/rpc/handlers/GetAggregatePrice.cpp
   src/ripple/rpc/handlers/LedgerAccept.cpp
   src/ripple/rpc/handlers/LedgerCleanerHandler.cpp
   src/ripple/rpc/handlers/LedgerClosed.cpp
@@ -658,13 +835,14 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/handlers/ValidatorListSites.cpp
   src/ripple/rpc/handlers/Validators.cpp
   src/ripple/rpc/handlers/WalletPropose.cpp
+  src/ripple/rpc/handlers/Catalogue.cpp
   src/ripple/rpc/impl/DeliveredAmount.cpp
   src/ripple/rpc/impl/Handler.cpp
   src/ripple/rpc/impl/LegacyPathFind.cpp
   src/ripple/rpc/impl/RPCHandler.cpp
   src/ripple/rpc/impl/RPCHelpers.cpp
   src/ripple/rpc/impl/Role.cpp
-  src/ripple/rpc/impl/ServerHandlerImp.cpp
+  src/ripple/rpc/impl/ServerHandler.cpp
   src/ripple/rpc/impl/ShardArchiveHandler.cpp
   src/ripple/rpc/impl/ShardVerificationScheduler.cpp
   src/ripple/rpc/impl/Status.cpp
@@ -674,13 +852,6 @@ target_sources (rippled PRIVATE
        subdir: perflog
   #]===============================]
   src/ripple/perflog/impl/PerfLogImp.cpp
-
-  #[===============================[
-     main sources:
-       subdir: server
-  #]===============================]
-  src/ripple/server/impl/JSONRPCUtil.cpp
-  src/ripple/server/impl/Port.cpp
   #[===============================[
      main sources:
        subdir: shamap
@@ -694,6 +865,7 @@ target_sources (rippled PRIVATE
   src/ripple/shamap/impl/SHAMapSync.cpp
   src/ripple/shamap/impl/SHAMapTreeNode.cpp
   src/ripple/shamap/impl/ShardFamily.cpp)
+# END XRPLD SOURCES
 
   #[===============================[
      test sources:
@@ -704,13 +876,18 @@ if (tests)
     src/test/app/AccountDelete_test.cpp
     src/test/app/AccountTxPaging_test.cpp
     src/test/app/AmendmentTable_test.cpp
+    src/test/app/AMM_test.cpp
+    src/test/app/AMMCalc_test.cpp
+    src/test/app/AMMExtended_test.cpp
     src/test/app/BaseFee_test.cpp
     src/test/app/Check_test.cpp
     src/test/app/ClaimReward_test.cpp
+    src/test/app/Clawback_test.cpp
     src/test/app/CrossingLimits_test.cpp
     src/test/app/DeliverMin_test.cpp
     src/test/app/DepositAuth_test.cpp
     src/test/app/Discrepancy_test.cpp
+    src/test/app/DID_test.cpp
     src/test/app/DNS_test.cpp
     src/test/app/Escrow_test.cpp
     src/test/app/FeeVote_test.cpp
@@ -733,6 +910,7 @@ if (tests)
     src/test/app/NFTokenDir_test.cpp
     src/test/app/OfferStream_test.cpp
     src/test/app/Offer_test.cpp
+    src/test/app/Oracle_test.cpp
     src/test/app/OversizeMeta_test.cpp
     src/test/app/Path_test.cpp
     src/test/app/PayChan_test.cpp
@@ -740,15 +918,21 @@ if (tests)
     src/test/app/PseudoTx_test.cpp
     src/test/app/RCLCensorshipDetector_test.cpp
     src/test/app/RCLValidations_test.cpp
+    src/test/app/ReducedOffer_test.cpp
     src/test/app/Regression_test.cpp
     src/test/app/Remit_test.cpp
     src/test/app/SHAMapStore_test.cpp
+    src/test/app/XChain_test.cpp
     src/test/app/SetAuth_test.cpp
+    src/test/app/SetHook_test.cpp
+    src/test/app/SetHookTSH_test.cpp
     src/test/app/SetRegularKey_test.cpp
+    src/test/app/SetRemarks_test.cpp
     src/test/app/SetTrust_test.cpp
     src/test/app/Taker_test.cpp
     src/test/app/TheoreticalQuality_test.cpp
     src/test/app/Ticket_test.cpp
+    src/test/app/Touch_test.cpp
     src/test/app/Transaction_ordering_test.cpp
     src/test/app/TrustAndBalance_test.cpp
     src/test/app/TxQ_test.cpp
@@ -756,8 +940,6 @@ if (tests)
     src/test/app/ValidatorKeys_test.cpp
     src/test/app/ValidatorList_test.cpp
     src/test/app/ValidatorSite_test.cpp
-    src/test/app/SetHook_test.cpp
-    src/test/app/SetHookTSH_test.cpp
     src/test/app/Wildcard_test.cpp
     src/test/app/XahauGenesis_test.cpp
     src/test/app/tx/apply_test.cpp
@@ -779,6 +961,7 @@ if (tests)
     src/test/basics/StringUtilities_test.cpp
     src/test/basics/TaggedCache_test.cpp
     src/test/basics/XRPAmount_test.cpp
+    src/test/basics/base58_test.cpp
     src/test/basics/base64_test.cpp
     src/test/basics/base_uint_test.cpp
     src/test/basics/contract_test.cpp
@@ -857,20 +1040,24 @@ if (tests)
     src/test/jtx/Env_test.cpp
     src/test/jtx/WSClient_test.cpp
     src/test/jtx/impl/Account.cpp
+    src/test/jtx/impl/AMM.cpp
+    src/test/jtx/impl/AMMTest.cpp
     src/test/jtx/impl/Env.cpp
     src/test/jtx/impl/JSONRPCClient.cpp
-    src/test/jtx/impl/ManualTimeKeeper.cpp
+    src/test/jtx/impl/Oracle.cpp
+    src/test/jtx/impl/TestHelpers.cpp
     src/test/jtx/impl/WSClient.cpp
     src/test/jtx/impl/hook.cpp
     src/test/jtx/impl/acctdelete.cpp
     src/test/jtx/impl/account_txn_id.cpp
     src/test/jtx/impl/amount.cpp
+    src/test/jtx/impl/attester.cpp
     src/test/jtx/impl/balance.cpp
     src/test/jtx/impl/check.cpp
     src/test/jtx/impl/delivermin.cpp
     src/test/jtx/impl/deposit.cpp
+    src/test/jtx/impl/did.cpp
     src/test/jtx/impl/envconfig.cpp
-    src/test/jtx/impl/escrow.cpp
     src/test/jtx/impl/fee.cpp
     src/test/jtx/impl/flags.cpp
     src/test/jtx/impl/genesis.cpp
@@ -891,9 +1078,11 @@ if (tests)
     src/test/jtx/impl/rate.cpp
     src/test/jtx/impl/regkey.cpp
     src/test/jtx/impl/reward.cpp
+    src/test/jtx/impl/remarks.cpp
     src/test/jtx/impl/remit.cpp
     src/test/jtx/impl/sendmax.cpp
     src/test/jtx/impl/seq.cpp
+    src/test/jtx/impl/xchain_bridge.cpp
     src/test/jtx/impl/sig.cpp
     src/test/jtx/impl/tag.cpp
     src/test/jtx/impl/ticket.cpp
@@ -952,11 +1141,13 @@ if (tests)
        test sources:
          subdir: protocol
     #]===============================]
+    src/test/protocol/ApiVersion_test.cpp
     src/test/protocol/BuildInfo_test.cpp
     src/test/protocol/InnerObjectFormats_test.cpp
     src/test/protocol/Issue_test.cpp
     src/test/protocol/Hooks_test.cpp
     src/test/protocol/Memo_test.cpp
+    src/test/protocol/MultiApiJson_test.cpp
     src/test/protocol/PublicKey_test.cpp
     src/test/protocol/Quality_test.cpp
     src/test/protocol/STAccount_test.cpp
@@ -980,23 +1171,27 @@ if (tests)
     #]===============================]
     src/test/rpc/AccountCurrencies_test.cpp
     src/test/rpc/AccountInfo_test.cpp
-    src/test/rpc/AccountLinesRPC_test.cpp
+    src/test/rpc/AccountLines_test.cpp
     src/test/rpc/AccountObjects_test.cpp
     src/test/rpc/AccountOffers_test.cpp
     src/test/rpc/AccountNamespace_test.cpp
     src/test/rpc/AccountSet_test.cpp
     src/test/rpc/AccountTx_test.cpp
     src/test/rpc/AmendmentBlocked_test.cpp
+    src/test/rpc/AMMInfo_test.cpp
     src/test/rpc/Book_test.cpp
+    src/test/rpc/Catalogue_test.cpp
     src/test/rpc/DepositAuthorized_test.cpp
     src/test/rpc/DeliveredAmount_test.cpp
     src/test/rpc/Feature_test.cpp
     src/test/rpc/GatewayBalances_test.cpp
+    src/test/rpc/GetAggregatePrice_test.cpp
     src/test/rpc/GetCounts_test.cpp
     src/test/rpc/JSONRPC_test.cpp
     src/test/rpc/KeyGeneration_test.cpp
     src/test/rpc/LedgerClosed_test.cpp
     src/test/rpc/LedgerData_test.cpp
+    src/test/rpc/LedgerHeader_test.cpp
     src/test/rpc/LedgerRPC_test.cpp
     src/test/rpc/LedgerRequestRPC_test.cpp
     src/test/rpc/ManifestRPC_test.cpp
@@ -1021,6 +1216,7 @@ if (tests)
     src/test/rpc/ValidatorInfo_test.cpp
     src/test/rpc/ValidatorRPC_test.cpp
     src/test/rpc/Version_test.cpp
+    src/test/rpc/Handler_test.cpp
     #[===============================[
        test sources:
          subdir: server

Builds/CMake/RippledCov.cmake

@@ -2,97 +2,37 @@
    coverage report target
 #]===================================================================]
 
-if (coverage)
-  if (is_clang)
-    if (APPLE)
-      execute_process (COMMAND xcrun -f llvm-profdata
-        OUTPUT_VARIABLE LLVM_PROFDATA
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-    else ()
-      find_program (LLVM_PROFDATA llvm-profdata)
-    endif ()
-    if (NOT LLVM_PROFDATA)
-      message (WARNING "unable to find llvm-profdata - skipping coverage_report target")
-    endif ()
+if(NOT coverage)
+  message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
+endif()
 
-    if (APPLE)
-      execute_process (COMMAND xcrun -f llvm-cov
-        OUTPUT_VARIABLE LLVM_COV
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-    else ()
-      find_program (LLVM_COV llvm-cov)
-    endif ()
-    if (NOT LLVM_COV)
-      message (WARNING "unable to find llvm-cov - skipping coverage_report target")
-    endif ()
+if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+  message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
+  return()
+endif()
 
-    set (extract_pattern "")
-    if (coverage_core_only)
-      set (extract_pattern "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/")
-    endif ()
+include(CodeCoverage)
 
-    if (LLVM_COV AND LLVM_PROFDATA)
-      add_custom_target (coverage_report
-        USES_TERMINAL
-        COMMAND ${CMAKE_COMMAND} -E echo "Generating coverage - results will be in ${CMAKE_BINARY_DIR}/coverage/index.html."
-        COMMAND ${CMAKE_COMMAND} -E echo "Running rippled tests."
-        COMMAND rippled --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --quiet --unittest-log
-        COMMAND ${LLVM_PROFDATA}
-          merge -sparse default.profraw -o rip.profdata
-        COMMAND ${CMAKE_COMMAND} -E echo "Summary of coverage:"
-        COMMAND ${LLVM_COV}
-          report -instr-profile=rip.profdata
-          $<TARGET_FILE:rippled> ${extract_pattern}
-        # generate html report
-        COMMAND ${LLVM_COV}
-          show -format=html -output-dir=${CMAKE_BINARY_DIR}/coverage
-          -instr-profile=rip.profdata
-          $<TARGET_FILE:rippled> ${extract_pattern}
-        BYPRODUCTS coverage/index.html)
-    endif ()
-  elseif (is_gcc)
-    find_program (LCOV lcov)
-    if (NOT LCOV)
-      message (WARNING "unable to find lcov - skipping coverage_report target")
-    endif ()
+# The instructions for these commands come from the `CodeCoverage` module,
+# which was copied from https://github.com/bilke/cmake-modules, commit fb7d2a3,
+# then locally changed (see CHANGES: section in `CodeCoverage.cmake`)
 
-    find_program (GENHTML genhtml)
-    if (NOT GENHTML)
-      message (WARNING "unable to find genhtml - skipping coverage_report target")
-    endif ()
+set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
+if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
+  separate_arguments(GCOVR_ADDITIONAL_ARGS)
+endif()
 
-    set (extract_pattern "*")
-    if (coverage_core_only)
-      set (extract_pattern "*/src/ripple/*")
-    endif ()
+list(APPEND GCOVR_ADDITIONAL_ARGS
+  --exclude-throw-branches
+  --exclude-noncode-lines
+  --exclude-unreachable-branches -s
+  -j ${coverage_test_parallelism})
 
-    if (LCOV AND GENHTML)
-      add_custom_target (coverage_report
-        USES_TERMINAL
-        COMMAND ${CMAKE_COMMAND} -E echo "Generating coverage- results will be in ${CMAKE_BINARY_DIR}/coverage/index.html."
-        # create baseline info file
-        COMMAND ${LCOV}
-          --no-external -d "${CMAKE_CURRENT_SOURCE_DIR}" -c -d . -i -o baseline.info
-          | grep -v "ignoring data for external file"
-        # run tests
-        COMMAND ${CMAKE_COMMAND} -E echo "Running rippled tests for coverage report."
-        COMMAND rippled --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --quiet --unittest-log
-        # Create test coverage data file
-        COMMAND ${LCOV}
-          --no-external -d "${CMAKE_CURRENT_SOURCE_DIR}" -c -d . -o tests.info
-          | grep -v "ignoring data for external file"
-        # Combine baseline and test coverage data
-        COMMAND ${LCOV}
-          -a baseline.info -a tests.info -o lcov-all.info
-        # extract our files
-        COMMAND ${LCOV}
-          -e lcov-all.info "${extract_pattern}" -o lcov.info
-        COMMAND ${CMAKE_COMMAND} -E echo "Summary of coverage:"
-        COMMAND ${LCOV} --summary lcov.info
-        # generate HTML report
-        COMMAND ${GENHTML}
-          -o ${CMAKE_BINARY_DIR}/coverage lcov.info
-        BYPRODUCTS coverage/index.html)
-    endif ()
-  endif ()
-endif ()
+setup_target_for_coverage_gcovr(
+  NAME coverage
+  FORMAT ${coverage_format}
+  EXECUTABLE rippled
+  EXECUTABLE_ARGS --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --unittest-jobs ${coverage_test_parallelism} --quiet --unittest-log
+  EXCLUDE "src/test" "${CMAKE_BINARY_DIR}/proto_gen" "${CMAKE_BINARY_DIR}/proto_gen_grpc"
+  DEPENDENCIES rippled
+)

Builds/CMake/RippledInstall.cmake

@@ -9,6 +9,7 @@ install (
     ripple_syslibs
     ripple_boost
     xrpl_core
+    xrpl.libpb
   EXPORT RippleExports
   LIBRARY DESTINATION lib
   ARCHIVE DESTINATION lib

Builds/CMake/RippledInterface.cmake

@@ -23,22 +23,29 @@ target_compile_options (opts
   INTERFACE
     $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
     $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-fprofile-arcs -ftest-coverage>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-fprofile-instr-generate -fcoverage-mapping>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-fprofile-arcs -ftest-coverage>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-fprofile-instr-generate -fcoverage-mapping>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
-if(jemalloc)
-  find_package(jemalloc REQUIRED)
-  target_compile_definitions(opts INTERFACE PROFILE_JEMALLOC)
-  target_link_libraries(opts INTERFACE jemalloc::jemalloc)
+if (jemalloc)
+  if (static)
+    set(JEMALLOC_USE_STATIC ON CACHE BOOL "" FORCE)
+  endif ()
+  find_package (jemalloc REQUIRED)
+  target_compile_definitions (opts INTERFACE PROFILE_JEMALLOC)
+  target_include_directories (opts SYSTEM INTERFACE ${JEMALLOC_INCLUDE_DIRS})
+  target_link_libraries (opts INTERFACE ${JEMALLOC_LIBRARIES})
+  get_filename_component (JEMALLOC_LIB_PATH ${JEMALLOC_LIBRARIES} DIRECTORY)
+  ## TODO see if we can use the BUILD_RPATH target property (is it transitive?)
+  set (CMAKE_BUILD_RPATH ${CMAKE_BUILD_RPATH} ${JEMALLOC_LIB_PATH})
 endif ()
 
 if (san)

Builds/CMake/RippledMultiConfig.cmake

@@ -14,7 +14,7 @@ if (is_multiconfig)
   file(GLOB md_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} CONFIGURE_DEPENDS
     *.md)
   LIST(APPEND all_sources ${md_files})
-  foreach (_target secp256k1::secp256k1 ed25519::ed25519 pbufs xrpl_core rippled)
+  foreach (_target secp256k1::secp256k1 ed25519::ed25519 xrpl_core rippled)
     get_target_property (_type ${_target} TYPE)
     if(_type STREQUAL "INTERFACE_LIBRARY")
       continue()

Builds/CMake/RippledNIH.cmake

@@ -0,0 +1,33 @@
+#[===================================================================[
+   NIH prefix path..this is where we will download
+   and build any ExternalProjects, and they will hopefully
+   survive across build directory deletion (manual cleans)
+#]===================================================================]
+
+string (REGEX REPLACE "[ \\/%]+" "_" gen_for_path ${CMAKE_GENERATOR})
+string (TOLOWER ${gen_for_path} gen_for_path)
+# HACK: trying to shorten paths for windows CI (which hits 260 MAXPATH easily)
+# @see:  https://issues.jenkins-ci.org/browse/JENKINS-38706?focusedCommentId=339847
+string (REPLACE "visual_studio" "vs" gen_for_path ${gen_for_path})
+if (NOT DEFINED NIH_CACHE_ROOT)
+  if (DEFINED ENV{NIH_CACHE_ROOT})
+    set (NIH_CACHE_ROOT $ENV{NIH_CACHE_ROOT})
+  else ()
+    set (NIH_CACHE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/.nih_c")
+  endif ()
+endif ()
+set (nih_cache_path
+  "${NIH_CACHE_ROOT}/${gen_for_path}/${CMAKE_CXX_COMPILER_ID}_${CMAKE_CXX_COMPILER_VERSION}")
+if (NOT is_multiconfig)
+  set (nih_cache_path "${nih_cache_path}/${CMAKE_BUILD_TYPE}")
+endif ()
+file(TO_CMAKE_PATH "${nih_cache_path}" nih_cache_path)
+message (STATUS "NIH-EP cache path: ${nih_cache_path}")
+## two convenience variables:
+set (ep_lib_prefix ${CMAKE_STATIC_LIBRARY_PREFIX})
+set (ep_lib_suffix ${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+# this is a setting for FetchContent and needs to be
+# a cache variable
+# https://cmake.org/cmake/help/latest/module/FetchContent.html#populating-the-content
+set (FETCHCONTENT_BASE_DIR ${nih_cache_path} CACHE STRING "" FORCE)

Builds/CMake/RippledSanity.cmake

@@ -2,6 +2,8 @@
    convenience variables and sanity checks
 #]===================================================================]
 
+include(ProcessorCount)
+
 if (NOT ep_procs)
   ProcessorCount(ep_procs)
   if (ep_procs GREATER 1)
@@ -10,7 +12,12 @@ if (NOT ep_procs)
     message (STATUS "Using ${ep_procs} cores for ExternalProject builds.")
   endif ()
 endif ()
-get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+get_property (is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if (is_multiconfig STREQUAL "NOTFOUND")
+  if (${CMAKE_GENERATOR} STREQUAL "Xcode" OR ${CMAKE_GENERATOR} MATCHES "^Visual Studio")
+    set (is_multiconfig TRUE)
+  endif ()
+endif ()
 
 set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
 if (NOT is_multiconfig)
@@ -44,6 +51,9 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     message (FATAL_ERROR "This project requires GCC 8 or later")
   endif ()
 endif ()
+if (CMAKE_GENERATOR STREQUAL "Xcode")
+  set (is_xcode TRUE)
+endif ()
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
   set (is_linux TRUE)

Builds/CMake/RippledSettings.cmake

@@ -2,121 +2,129 @@
    declare user options/settings
 #]===================================================================]
 
-option (assert "Enables asserts, even in release builds" OFF)
+include(ProcessorCount)
 
-option (reporting "Build rippled with reporting mode enabled" OFF)
+ProcessorCount(PROCESSOR_COUNT)
 
-option (tests "Build tests" ON)
+option(assert "Enables asserts, even in release builds" OFF)
 
-option (unity "Creates a build using UNITY support in cmake. This is the default" ON)
-if (unity)
-  if (NOT is_ci)
-    set (CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
-  endif ()
-endif ()
-if (is_gcc OR is_clang)
-  option (coverage "Generates coverage info." OFF)
-  option (profile "Add profiling flags" OFF)
-  set (coverage_test "" CACHE STRING
+option(reporting "Build rippled with reporting mode enabled" OFF)
+
+option(tests "Build tests" ON)
+
+option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
+if(unity)
+  if(NOT is_ci)
+    set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
+  endif()
+endif()
+if(is_gcc OR is_clang)
+  option(coverage "Generates coverage info." OFF)
+  option(profile "Add profiling flags" OFF)
+  set(coverage_test_parallelism "${PROCESSOR_COUNT}" CACHE STRING
+    "Unit tests parallelism for the purpose of coverage report.")
+  set(coverage_format "html-details" CACHE STRING
+    "Output format of the coverage report.")
+  set(coverage_extra_args "" CACHE STRING
+    "Additional arguments to pass to gcovr.")
+  set(coverage_test "" CACHE STRING
     "On gcc & clang, the specific unit test(s) to run for coverage. Default is all tests.")
-  if (coverage_test AND NOT coverage)
-    set (coverage ON CACHE BOOL "gcc/clang only" FORCE)
-  endif ()
-  option (coverage_core_only
-    "Include only src/ripple files when generating coverage report. \
-    Set to OFF to include all sources in coverage report."
-    ON)
-  option (wextra "compile with extra gcc/clang warnings enabled" ON)
-else ()
-  set (profile OFF CACHE BOOL "gcc/clang only" FORCE)
-  set (coverage OFF CACHE BOOL "gcc/clang only" FORCE)
-  set (wextra OFF CACHE BOOL "gcc/clang only" FORCE)
-endif ()
-if (is_linux)
-  option (BUILD_SHARED_LIBS "build shared ripple libraries" OFF)
-  option (static "link protobuf, openssl, libc++, and boost statically" ON)
-  option (perf "Enables flags that assist with perf recording" OFF)
-  option (use_gold "enables detection of gold (binutils) linker" ON)
-else ()
+  if(coverage_test AND NOT coverage)
+    set(coverage ON CACHE BOOL "gcc/clang only" FORCE)
+  endif()
+  option(wextra "compile with extra gcc/clang warnings enabled" ON)
+else()
+  set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
+  set(coverage OFF CACHE BOOL "gcc/clang only" FORCE)
+  set(wextra OFF CACHE BOOL "gcc/clang only" FORCE)
+endif()
+if(is_linux)
+  option(BUILD_SHARED_LIBS "build shared ripple libraries" OFF)
+  option(static "link protobuf, openssl, libc++, and boost statically" ON)
+  option(perf "Enables flags that assist with perf recording" OFF)
+  option(use_gold "enables detection of gold (binutils) linker" ON)
+  option(use_mold "enables detection of mold (binutils) linker" ON)
+else()
   # we are not ready to allow shared-libs on windows because it would require
   # export declarations. On macos it's more feasible, but static openssl
   # produces odd linker errors, thus we disable shared lib builds for now.
-  set (BUILD_SHARED_LIBS OFF CACHE BOOL "build shared ripple libraries - OFF for win/macos" FORCE)
-  set (static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
-  set (perf OFF CACHE BOOL "perf flags, linux only" FORCE)
-  set (use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
-endif ()
-if (is_clang)
-  option (use_lld "enables detection of lld linker" ON)
-else ()
-  set (use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
-endif ()
-option (jemalloc "Enables jemalloc for heap profiling" OFF)
-option (werr "treat warnings as errors" OFF)
-option (local_protobuf
+  set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared ripple libraries - OFF for win/macos" FORCE)
+  set(static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
+  set(perf OFF CACHE BOOL "perf flags, linux only" FORCE)
+  set(use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
+  set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
+endif()
+if(is_clang)
+  option(use_lld "enables detection of lld linker" ON)
+else()
+  set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
+endif()
+option(jemalloc "Enables jemalloc for heap profiling" OFF)
+option(werr "treat warnings as errors" OFF)
+option(local_protobuf
   "Force a local build of protobuf instead of looking for an installed version." OFF)
-option (local_grpc
+option(local_grpc
   "Force a local build of gRPC instead of looking for an installed version." OFF)
 
 # this one is a string and therefore can't be an option
-set (san "" CACHE STRING "On gcc & clang, add sanitizer instrumentation")
-set_property (CACHE san PROPERTY STRINGS ";undefined;memory;address;thread")
-if (san)
-  string (TOLOWER ${san} san)
-  set (SAN_FLAG "-fsanitize=${san}")
-  set (SAN_LIB "")
-  if (is_gcc)
-    if (san STREQUAL "address")
-      set (SAN_LIB "asan")
-    elseif (san STREQUAL "thread")
-      set (SAN_LIB "tsan")
-    elseif (san STREQUAL "memory")
-      set (SAN_LIB "msan")
-    elseif (san STREQUAL "undefined")
-      set (SAN_LIB "ubsan")
-    endif ()
-  endif ()
-  set (_saved_CRL ${CMAKE_REQUIRED_LIBRARIES})
-  set (CMAKE_REQUIRED_LIBRARIES "${SAN_FLAG};${SAN_LIB}")
-  check_cxx_compiler_flag (${SAN_FLAG} COMPILER_SUPPORTS_SAN)
-  set (CMAKE_REQUIRED_LIBRARIES ${_saved_CRL})
-  if (NOT COMPILER_SUPPORTS_SAN)
-    message (FATAL_ERROR "${san} sanitizer does not seem to be supported by your compiler")
-  endif ()
-endif ()
-set (container_label "" CACHE STRING "tag to use for package building containers")
-option (packages_only
+set(san "" CACHE STRING "On gcc & clang, add sanitizer instrumentation")
+set_property(CACHE san PROPERTY STRINGS ";undefined;memory;address;thread")
+if(san)
+  string(TOLOWER ${san} san)
+  set(SAN_FLAG "-fsanitize=${san}")
+  set(SAN_LIB "")
+  if(is_gcc)
+    if(san STREQUAL "address")
+      set(SAN_LIB "asan")
+    elseif(san STREQUAL "thread")
+      set(SAN_LIB "tsan")
+    elseif(san STREQUAL "memory")
+      set(SAN_LIB "msan")
+    elseif(san STREQUAL "undefined")
+      set(SAN_LIB "ubsan")
+    endif()
+  endif()
+  set(_saved_CRL ${CMAKE_REQUIRED_LIBRARIES})
+  set(CMAKE_REQUIRED_LIBRARIES "${SAN_FLAG};${SAN_LIB}")
+  check_cxx_compiler_flag(${SAN_FLAG} COMPILER_SUPPORTS_SAN)
+  set(CMAKE_REQUIRED_LIBRARIES ${_saved_CRL})
+  if(NOT COMPILER_SUPPORTS_SAN)
+    message(FATAL_ERROR "${san} sanitizer does not seem to be supported by your compiler")
+  endif()
+endif()
+set(container_label "" CACHE STRING "tag to use for package building containers")
+option(packages_only
   "ONLY generate package building targets. This is special use-case and almost \
    certainly not what you want. Use with caution as you won't be able to build \
    any compiled targets locally." OFF)
-option (have_package_container
+option(have_package_container
   "Sometimes you already have the tagged container you want to use for package \
    building and you don't want docker to rebuild it. This flag will detach the \
    dependency of the package build from the container build. It's an advanced \
    use case and most likely you should not be touching this flag." OFF)
 
 # the remaining options are obscure and rarely used
-option (beast_no_unit_test_inline
+option(beast_no_unit_test_inline
   "Prevents unit test definitions from being inserted into global table"
   OFF)
-option (single_io_service_thread
+option(single_io_service_thread
   "Restricts the number of threads calling io_service::run to one. \
   This can be useful when debugging."
   OFF)
-option (boost_show_deprecated
+option(boost_show_deprecated
   "Allow boost to fail on deprecated usage. Only useful if you're trying\
   to find deprecated calls."
   OFF)
-option (beast_hashers
+option(beast_hashers
   "Use local implementations for sha/ripemd hashes (experimental, not recommended)"
   OFF)
 
-if (WIN32)
-  option (beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
-else ()
-  set (beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
-endif ()
-if (coverage)
-  message (STATUS "coverage build requested - forcing Debug build")
-  set (CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
-endif ()
+if(WIN32)
+  option(beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
+else()
+  set(beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
+endif()
+if(coverage)
+  message(STATUS "coverage build requested - forcing Debug build")
+  set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
+endif()

Builds/CMake/RippledValidatorKeys.cmake

@@ -2,9 +2,9 @@ option (validator_keys "Enables building of validator-keys-tool as a separate ta
 
 if (validator_keys)
   git_branch (current_branch)
-  # default to tracking VK develop branch unless we are on master/release
-  if (NOT (current_branch STREQUAL "master" OR current_branch STREQUAL "release"))
-    set (current_branch "develop")
+  # default to tracking VK master branch unless we are on release
+  if (NOT (current_branch STREQUAL "release"))
+    set (current_branch "master")
   endif ()
   message (STATUS "tracking ValidatorKeys branch: ${current_branch}")
 

Builds/CMake/SociConfig.cmake.patched

@@ -1,106 +0,0 @@
-################################################################################
-# SociConfig.cmake - CMake build configuration of SOCI library
-################################################################################
-# Copyright (C) 2010 Mateusz Loskot <mateusz@loskot.net>
-#
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-################################################################################
-
-include(CheckCXXSymbolExists)
-
-if(WIN32)
-  check_cxx_symbol_exists("_M_AMD64" "" SOCI_TARGET_ARCH_X64)
-  if(NOT RTC_ARCH_X64)
-    check_cxx_symbol_exists("_M_IX86" "" SOCI_TARGET_ARCH_X86)
-  endif(NOT RTC_ARCH_X64)
-  # add check for arm here
-  # see http://msdn.microsoft.com/en-us/library/b0084kay.aspx
-else(WIN32)
-  check_cxx_symbol_exists("__i386__" "" SOCI_TARGET_ARCH_X86)
-  check_cxx_symbol_exists("__x86_64__" "" SOCI_TARGET_ARCH_X64)
-  check_cxx_symbol_exists("__arm__" "" SOCI_TARGET_ARCH_ARM)
-endif(WIN32)
-
-if(NOT DEFINED LIB_SUFFIX)
-  if(SOCI_TARGET_ARCH_X64)
-    set(_lib_suffix "64")
-  else()
-    set(_lib_suffix "")
-  endif()
-  set(LIB_SUFFIX ${_lib_suffix} CACHE STRING "Specifies suffix for the lib directory")
-endif()
-
-#
-# C++11 Option
-#
-
-if(NOT SOCI_CXX_C11)
-  set (SOCI_CXX_C11 OFF CACHE BOOL "Build to the C++11 standard")
-endif()
-
-#
-# Force compilation flags and set desired warnings level
-#
-
-if (MSVC)
-  add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
-  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-  add_definitions(-D_CRT_NONSTDC_NO_WARNING)
-  add_definitions(-D_SCL_SECURE_NO_WARNINGS)
-
-  if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /we4266")
-  endif()
-
-else()
-
-  set(SOCI_GCC_CLANG_COMMON_FLAGS "")
-    # "-pedantic -Werror -Wno-error=parentheses -Wall -Wextra -Wpointer-arith -Wcast-align -Wcast-qual -Wfloat-equal -Woverloaded-virtual -Wredundant-decls -Wno-long-long")
-
-
-  if (SOCI_CXX_C11)
-    set(SOCI_CXX_VERSION_FLAGS "-std=c++11")
-  else()
-    set(SOCI_CXX_VERSION_FLAGS "-std=gnu++98")
-  endif()
-
-  if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER}" MATCHES "clang")
-
-    if(NOT CMAKE_CXX_COMPILER_VERSION LESS 3.1 AND SOCI_ASAN)
-      set(SOCI_GCC_CLANG_COMMON_FLAGS "${SOCI_GCC_CLANG_COMMON_FLAGS} -fsanitize=address")
-    endif()
-
-    # enforce C++11 for Clang
-    set(SOCI_CXX_C11 ON)
-    set(SOCI_CXX_VERSION_FLAGS "-std=c++11")
-    add_definitions(-DCATCH_CONFIG_CPP11_NO_IS_ENUM)
-
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SOCI_GCC_CLANG_COMMON_FLAGS} ${SOCI_CXX_VERSION_FLAGS}")
-
-  elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-
-    if(NOT CMAKE_CXX_COMPILER_VERSION LESS 4.8 AND SOCI_ASAN)
-      set(SOCI_GCC_CLANG_COMMON_FLAGS "${SOCI_GCC_CLANG_COMMON_FLAGS} -fsanitize=address")
-    endif()
-
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SOCI_GCC_CLANG_COMMON_FLAGS} ${SOCI_CXX_VERSION_FLAGS} ")
-    if (CMAKE_COMPILER_IS_GNUCXX)
-        if (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        else()
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-variadic-macros")
-        endif()
-    endif()
-
-  else()
-	message(WARNING "Unknown toolset - using default flags to build SOCI")
-  endif()
-
-endif()
-
-# Set SOCI_HAVE_* variables for soci-config.h generator
-set(SOCI_HAVE_CXX_C11 ${SOCI_CXX_C11} CACHE INTERNAL "Enables C++11 support")

Builds/CMake/conan/Boost.cmake

@@ -0,0 +1,54 @@
+find_package(Boost 1.83 REQUIRED
+  COMPONENTS
+    chrono
+    container
+    context
+    coroutine
+    date_time
+    filesystem
+    json
+    program_options
+    regex
+    system
+    thread
+)
+
+add_library(ripple_boost INTERFACE)
+add_library(Ripple::boost ALIAS ripple_boost)
+if(XCODE)
+  target_include_directories(ripple_boost BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
+  target_compile_options(ripple_boost INTERFACE --system-header-prefix="boost/")
+else()
+  target_include_directories(ripple_boost SYSTEM BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
+endif()
+
+target_link_libraries(ripple_boost
+  INTERFACE
+    Boost::boost
+    Boost::chrono
+    Boost::container
+    Boost::coroutine
+    Boost::date_time
+    Boost::filesystem
+    Boost::json
+    Boost::program_options
+    Boost::regex
+    Boost::system
+    Boost::iostreams
+    Boost::thread)
+if(Boost_COMPILER)
+  target_link_libraries(ripple_boost INTERFACE Boost::disable_autolinking)
+endif()
+if(san AND is_clang)
+  # TODO: gcc does not support -fsanitize-blacklist...can we do something else
+  # for gcc ?
+  if(NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
+    get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
+  endif()
+  message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
+  target_compile_options(opts
+    INTERFACE
+      # ignore boost headers for sanitizing
+      -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
+endif()

Builds/CMake/deps/Boost.cmake

@@ -1,4 +1,52 @@
-find_package(Boost 1.70 REQUIRED
+#[===================================================================[
+   NIH dep: boost
+#]===================================================================]
+if((NOT DEFINED BOOST_ROOT) AND(DEFINED ENV{BOOST_ROOT}))
+  set(BOOST_ROOT $ENV{BOOST_ROOT})
+endif()
+if((NOT DEFINED BOOST_LIBRARYDIR) AND(DEFINED ENV{BOOST_LIBRARYDIR}))
+  set(BOOST_LIBRARYDIR $ENV{BOOST_LIBRARYDIR})
+endif()
+file(TO_CMAKE_PATH "${BOOST_ROOT}" BOOST_ROOT)
+if(WIN32 OR CYGWIN)
+  # Workaround for MSVC having two boost versions - x86 and x64 on same PC in stage folders
+  if((NOT DEFINED BOOST_LIBRARYDIR) AND (DEFINED BOOST_ROOT))
+    if(IS_DIRECTORY ${BOOST_ROOT}/stage64/lib)
+      set(BOOST_LIBRARYDIR ${BOOST_ROOT}/stage64/lib)
+    elseif(IS_DIRECTORY ${BOOST_ROOT}/stage/lib)
+      set(BOOST_LIBRARYDIR ${BOOST_ROOT}/stage/lib)
+    elseif(IS_DIRECTORY ${BOOST_ROOT}/lib)
+      set(BOOST_LIBRARYDIR ${BOOST_ROOT}/lib)
+    else()
+      message(WARNING "Did not find expected boost library dir. "
+        "Defaulting to ${BOOST_ROOT}")
+      set(BOOST_LIBRARYDIR ${BOOST_ROOT})
+    endif()
+  endif()
+endif()
+message(STATUS "BOOST_ROOT: ${BOOST_ROOT}")
+message(STATUS "BOOST_LIBRARYDIR: ${BOOST_LIBRARYDIR}")
+
+# uncomment the following as needed to debug FindBoost issues:
+#set(Boost_DEBUG ON)
+
+#[=========================================================[
+   boost dynamic libraries don't trivially support @rpath
+   linking right now (cmake's default), so just force
+   static linking for macos, or if requested on linux by flag
+#]=========================================================]
+if(static)
+  set(Boost_USE_STATIC_LIBS ON)
+endif()
+set(Boost_USE_MULTITHREADED ON)
+if(static AND NOT APPLE)
+  set(Boost_USE_STATIC_RUNTIME ON)
+else()
+  set(Boost_USE_STATIC_RUNTIME OFF)
+endif()
+# TBD:
+# Boost_USE_DEBUG_RUNTIME:  When ON, uses Boost libraries linked against the
+find_package(Boost 1.86 REQUIRED
   COMPONENTS
     chrono
     container
@@ -6,15 +54,16 @@ find_package(Boost 1.70 REQUIRED
     coroutine
     date_time
     filesystem
+    json
     program_options
     regex
     system
-    thread
-)
+    iostreams
+    thread)
 
 add_library(ripple_boost INTERFACE)
 add_library(Ripple::boost ALIAS ripple_boost)
-if(XCODE)
+if(is_xcode)
   target_include_directories(ripple_boost BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
   target_compile_options(ripple_boost INTERFACE --system-header-prefix="boost/")
 else()
@@ -29,6 +78,8 @@ target_link_libraries(ripple_boost
     Boost::coroutine
     Boost::date_time
     Boost::filesystem
+    Boost::json
+    Boost::iostreams
     Boost::program_options
     Boost::regex
     Boost::system

Builds/CMake/deps/Ed25519-donna.cmake

@@ -0,0 +1,28 @@
+#[===================================================================[
+   NIH dep: ed25519-donna
+#]===================================================================]
+
+add_library (ed25519-donna STATIC
+  external/ed25519-donna/ed25519.c)
+target_include_directories (ed25519-donna
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/external>
+    $<INSTALL_INTERFACE:include>
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/external/ed25519-donna)
+#[=========================================================[
+   NOTE for macos:
+   https://github.com/floodyberry/ed25519-donna/issues/29
+   our source for ed25519-donna-portable.h has been
+   patched to workaround this.
+#]=========================================================]
+target_link_libraries (ed25519-donna PUBLIC OpenSSL::SSL)
+add_library (NIH::ed25519-donna ALIAS ed25519-donna)
+target_link_libraries (ripple_libs INTERFACE NIH::ed25519-donna)
+#[===========================[
+   headers installation
+#]===========================]
+install (
+  FILES
+    external/ed25519-donna/ed25519.h
+  DESTINATION include/ed25519-donna)

Builds/CMake/deps/Findjemalloc.cmake

@@ -0,0 +1,47 @@
+# - Try to find jemalloc
+# Once done this will define
+#  JEMALLOC_FOUND - System has jemalloc
+#  JEMALLOC_INCLUDE_DIRS - The jemalloc include directories
+#  JEMALLOC_LIBRARIES - The libraries needed to use jemalloc
+
+if(NOT USE_BUNDLED_JEMALLOC)
+  find_package(PkgConfig)
+  if (PKG_CONFIG_FOUND)
+    pkg_check_modules(PC_JEMALLOC QUIET jemalloc)
+  endif()
+else()
+  set(PC_JEMALLOC_INCLUDEDIR)
+  set(PC_JEMALLOC_INCLUDE_DIRS)
+  set(PC_JEMALLOC_LIBDIR)
+  set(PC_JEMALLOC_LIBRARY_DIRS)
+  set(LIMIT_SEARCH NO_DEFAULT_PATH)
+endif()
+
+set(JEMALLOC_DEFINITIONS ${PC_JEMALLOC_CFLAGS_OTHER})
+
+find_path(JEMALLOC_INCLUDE_DIR jemalloc/jemalloc.h
+          PATHS ${PC_JEMALLOC_INCLUDEDIR} ${PC_JEMALLOC_INCLUDE_DIRS}
+          ${LIMIT_SEARCH})
+
+# If we're asked to use static linkage, add libjemalloc.a as a preferred library name.
+if(JEMALLOC_USE_STATIC)
+  list(APPEND JEMALLOC_NAMES
+    "${CMAKE_STATIC_LIBRARY_PREFIX}jemalloc${CMAKE_STATIC_LIBRARY_SUFFIX}")
+endif()
+
+list(APPEND JEMALLOC_NAMES jemalloc)
+
+find_library(JEMALLOC_LIBRARY NAMES ${JEMALLOC_NAMES}
+  HINTS ${PC_JEMALLOC_LIBDIR} ${PC_JEMALLOC_LIBRARY_DIRS}
+  ${LIMIT_SEARCH})
+
+set(JEMALLOC_LIBRARIES ${JEMALLOC_LIBRARY})
+set(JEMALLOC_INCLUDE_DIRS ${JEMALLOC_INCLUDE_DIR})
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set JEMALLOC_FOUND to TRUE
+# if all listed variables are TRUE
+find_package_handle_standard_args(JeMalloc DEFAULT_MSG
+  JEMALLOC_LIBRARY JEMALLOC_INCLUDE_DIR)
+
+mark_as_advanced(JEMALLOC_INCLUDE_DIR JEMALLOC_LIBRARY)

Builds/CMake/deps/Findlibarchive_pc.cmake

@@ -0,0 +1,22 @@
+find_package (PkgConfig REQUIRED)
+pkg_search_module (libarchive_PC QUIET libarchive>=3.4.3)
+
+if(static)
+  set(LIBARCHIVE_LIB libarchive.a)
+else()
+  set(LIBARCHIVE_LIB archive)
+endif()
+
+find_library (archive
+  NAMES ${LIBARCHIVE_LIB}
+  HINTS
+    ${libarchive_PC_LIBDIR}
+    ${libarchive_PC_LIBRARY_DIRS}
+  NO_DEFAULT_PATH)
+
+find_path (LIBARCHIVE_INCLUDE_DIR
+  NAMES archive.h
+  HINTS
+    ${libarchive_PC_INCLUDEDIR}
+    ${libarchive_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Findlz4.cmake

@@ -0,0 +1,24 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  pkg_search_module (lz4_PC QUIET liblz4>=1.9)
+endif ()
+
+if(static)
+  set(LZ4_LIB liblz4.a)
+else()
+  set(LZ4_LIB lz4.so)
+endif()
+
+find_library (lz4
+  NAMES ${LZ4_LIB}
+  HINTS
+    ${lz4_PC_LIBDIR}
+    ${lz4_PC_LIBRARY_DIRS}
+  NO_DEFAULT_PATH)
+
+find_path (LZ4_INCLUDE_DIR
+  NAMES lz4.h
+  HINTS
+    ${lz4_PC_INCLUDEDIR}
+    ${lz4_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Findsecp256k1.cmake

@@ -0,0 +1,24 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  pkg_search_module (secp256k1_PC QUIET libsecp256k1)
+endif ()
+
+if(static)
+  set(SECP256K1_LIB libsecp256k1.a)
+else()
+  set(SECP256K1_LIB secp256k1)
+endif()
+
+find_library(secp256k1
+  NAMES ${SECP256K1_LIB}
+  HINTS
+    ${secp256k1_PC_LIBDIR}
+    ${secp256k1_PC_LIBRARY_PATHS}
+  NO_DEFAULT_PATH)
+
+find_path (SECP256K1_INCLUDE_DIR
+  NAMES secp256k1.h
+  HINTS
+    ${secp256k1_PC_INCLUDEDIR}
+    ${secp256k1_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Findsnappy.cmake

@@ -0,0 +1,24 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  pkg_search_module (snappy_PC QUIET snappy>=1.1.7)
+endif ()
+
+if(static)
+  set(SNAPPY_LIB libsnappy.a)
+else()
+  set(SNAPPY_LIB libsnappy.so)
+endif()
+
+find_library (snappy
+  NAMES ${SNAPPY_LIB}
+  HINTS
+    ${snappy_PC_LIBDIR}
+    ${snappy_PC_LIBRARY_DIRS}
+  NO_DEFAULT_PATH)
+
+find_path (SNAPPY_INCLUDE_DIR
+  NAMES snappy.h
+  HINTS
+    ${snappy_PC_INCLUDEDIR}
+    ${snappy_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Findsoci.cmake

@@ -0,0 +1,19 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  # TBD - currently no soci pkgconfig
+  #pkg_search_module (soci_PC QUIET libsoci_core>=3.2)
+endif ()
+
+if(static)
+  set(SOCI_LIB libsoci.a)
+else()
+  set(SOCI_LIB libsoci_core.so)
+endif()
+
+find_library (soci
+  NAMES ${SOCI_LIB})
+
+find_path (SOCI_INCLUDE_DIR
+  NAMES soci/soci.h)
+
+message("SOCI FOUND AT: ${SOCI_LIB}")

Builds/CMake/deps/Findsqlite.cmake

@@ -0,0 +1,24 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  pkg_search_module (sqlite_PC QUIET sqlite3>=3.26.0)
+endif ()
+
+if(static)
+  set(SQLITE_LIB libsqlite3.a)
+else()
+  set(SQLITE_LIB sqlite3.so)
+endif()
+
+find_library (sqlite3
+  NAMES ${SQLITE_LIB}
+  HINTS
+    ${sqlite_PC_LIBDIR}
+    ${sqlite_PC_LIBRARY_DIRS}
+  NO_DEFAULT_PATH)
+
+find_path (SQLITE_INCLUDE_DIR
+  NAMES sqlite3.h
+  HINTS
+    ${sqlite_PC_INCLUDEDIR}
+    ${sqlite_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Libarchive.cmake

@@ -0,0 +1,163 @@
+#[===================================================================[
+   NIH dep: libarchive
+#]===================================================================]
+
+option (local_libarchive "use local build of libarchive." OFF)
+add_library (archive_lib UNKNOWN IMPORTED GLOBAL)
+
+if (NOT local_libarchive)
+  if (NOT WIN32)
+    find_package(libarchive_pc REQUIRED)
+  endif ()
+  if (archive)
+    message (STATUS "Found libarchive using pkg-config. Using ${archive}.")
+    set_target_properties (archive_lib PROPERTIES
+      IMPORTED_LOCATION_DEBUG
+        ${archive}
+      IMPORTED_LOCATION_RELEASE
+        ${archive}
+      INTERFACE_INCLUDE_DIRECTORIES
+        ${LIBARCHIVE_INCLUDE_DIR})
+      # pkg-config can return extra info for static lib linking
+      # this is probably needed/useful generally, but apply
+      # to APPLE for now (mostly for homebrew)
+      if (APPLE AND static AND libarchive_PC_STATIC_LIBRARIES)
+        message(STATUS "NOTE: libarchive static libs: ${libarchive_PC_STATIC_LIBRARIES}")
+        # also, APPLE seems to need iconv...maybe linux does too (TBD)
+        target_link_libraries (archive_lib
+          INTERFACE iconv ${libarchive_PC_STATIC_LIBRARIES})
+      endif ()
+  else ()
+    ## now try searching using the minimal find module that cmake provides
+    find_package(LibArchive 3.4.3 QUIET)
+    if (LibArchive_FOUND)
+      if (static)
+        # find module doesn't find static libs currently, so we re-search
+        get_filename_component(_loc ${LibArchive_LIBRARY} DIRECTORY)
+        find_library(_la_static
+          NAMES libarchive.a archive_static.lib archive.lib
+          PATHS ${_loc})
+        if (_la_static)
+          set (_la_lib ${_la_static})
+        else ()
+          message (WARNING "unable to find libarchive static lib - switching to local build")
+          set (local_libarchive ON CACHE BOOL "" FORCE)
+        endif ()
+      else ()
+        set (_la_lib ${LibArchive_LIBRARY})
+      endif ()
+      if (NOT local_libarchive)
+        message (STATUS "Found libarchive using module/config. Using ${_la_lib}.")
+        set_target_properties (archive_lib PROPERTIES
+          IMPORTED_LOCATION_DEBUG
+            ${_la_lib}
+          IMPORTED_LOCATION_RELEASE
+            ${_la_lib}
+          INTERFACE_INCLUDE_DIRECTORIES
+            ${LibArchive_INCLUDE_DIRS})
+      endif ()
+    else ()
+      set (local_libarchive ON CACHE BOOL "" FORCE)
+    endif ()
+  endif ()
+endif()
+
+if (local_libarchive)
+  set (lib_post "")
+  if (MSVC)
+    set (lib_post "_static")
+  endif ()
+  ExternalProject_Add (libarchive
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/libarchive/libarchive.git
+    GIT_TAG v3.4.3
+    CMAKE_ARGS
+      # passing the compiler seems to be needed for windows CI, sadly
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DENABLE_LZ4=ON
+      -ULZ4_*
+      -DLZ4_INCLUDE_DIR=$<JOIN:$<TARGET_PROPERTY:lz4_lib,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      # because we are building a static lib, this lz4 library doesn't
+      # actually matter since you can't generally link static libs to other static
+      # libs. The include files are needed, but the library itself is not (until
+      # we link our application, at which point we use the lz4 we built above).
+      # nonetheless, we need to provide a library to libarchive else it will
+      # NOT include lz4 support when configuring
+      -DLZ4_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:lz4_lib,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:lz4_lib,IMPORTED_LOCATION_RELEASE>>
+      -DENABLE_WERROR=OFF
+      -DENABLE_TAR=OFF
+      -DENABLE_TAR_SHARED=OFF
+      -DENABLE_INSTALL=ON
+      -DENABLE_NETTLE=OFF
+      -DENABLE_OPENSSL=OFF
+      -DENABLE_LZO=OFF
+      -DENABLE_LZMA=OFF
+      -DENABLE_ZLIB=OFF
+      -DENABLE_BZip2=OFF
+      -DENABLE_LIBXML2=OFF
+      -DENABLE_EXPAT=OFF
+      -DENABLE_PCREPOSIX=OFF
+      -DENABLE_LibGCC=OFF
+      -DENABLE_CNG=OFF
+      -DENABLE_CPIO=OFF
+      -DENABLE_CPIO_SHARED=OFF
+      -DENABLE_CAT=OFF
+      -DENABLE_CAT_SHARED=OFF
+      -DENABLE_XATTR=OFF
+      -DENABLE_ACL=OFF
+      -DENABLE_ICONV=OFF
+      -DENABLE_TEST=OFF
+      -DENABLE_COVERAGE=OFF
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_C_FLAGS_RELEASE=-MT"
+      >
+    LIST_SEPARATOR ::
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --target archive_static
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+            <BINARY_DIR>/libarchive/$<CONFIG>/${ep_lib_prefix}archive${lib_post}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/libarchive
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS lz4_lib
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/libarchive/${ep_lib_prefix}archive${lib_post}${ep_lib_suffix}
+      <BINARY_DIR>/libarchive/${ep_lib_prefix}archive${lib_post}_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (libarchive BINARY_DIR)
+  ExternalProject_Get_Property (libarchive SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (libarchive)
+  endif ()
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/libarchive)
+  set_target_properties (archive_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/libarchive/${ep_lib_prefix}archive${lib_post}_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/libarchive/${ep_lib_prefix}archive${lib_post}${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR}/libarchive
+    INTERFACE_COMPILE_DEFINITIONS
+      LIBARCHIVE_STATIC)
+endif()
+
+add_dependencies (archive_lib libarchive)
+target_link_libraries (archive_lib INTERFACE lz4_lib)
+target_link_libraries (ripple_libs INTERFACE archive_lib)
+exclude_if_included (libarchive)
+exclude_if_included (archive_lib)

Builds/CMake/deps/Lz4.cmake

@@ -0,0 +1,79 @@
+#[===================================================================[
+   NIH dep: lz4
+#]===================================================================]
+
+add_library (lz4_lib STATIC IMPORTED GLOBAL)
+
+if (NOT WIN32)
+  find_package(lz4)
+endif()
+
+if(lz4)
+  set_target_properties (lz4_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${lz4}
+    IMPORTED_LOCATION_RELEASE
+      ${lz4}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${LZ4_INCLUDE_DIR})
+
+else()
+  ExternalProject_Add (lz4
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/lz4/lz4.git
+    GIT_TAG v1.9.2
+    SOURCE_SUBDIR contrib/cmake_unofficial
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DBUILD_STATIC_LIBS=ON
+      -DBUILD_SHARED_LIBS=OFF
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_C_FLAGS_RELEASE=-MT"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --target lz4_static
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+          <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}lz4$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/${ep_lib_prefix}lz4${ep_lib_suffix}
+      <BINARY_DIR>/${ep_lib_prefix}lz4_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (lz4 BINARY_DIR)
+  ExternalProject_Get_Property (lz4 SOURCE_DIR)
+
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/lz4)
+  set_target_properties (lz4_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/${ep_lib_prefix}lz4_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/${ep_lib_prefix}lz4${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR}/lib)
+
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (lz4)
+  endif ()
+  add_dependencies (lz4_lib lz4)
+  target_link_libraries (ripple_libs INTERFACE lz4_lib)
+  exclude_if_included (lz4)
+endif()
+
+exclude_if_included (lz4_lib)

Builds/CMake/deps/Nudb.cmake

@@ -0,0 +1,31 @@
+#[===================================================================[
+   NIH dep: nudb
+
+   NuDB is header-only, thus is an INTERFACE lib in CMake.
+   TODO: move the library definition into NuDB repo and add
+   proper targets and export/install
+#]===================================================================]
+
+if (is_root_project) # NuDB not needed in the case of xrpl_core inclusion build
+  add_library (nudb INTERFACE)
+  FetchContent_Declare(
+    nudb_src
+    GIT_REPOSITORY https://github.com/CPPAlliance/NuDB.git
+    GIT_TAG        2.0.5
+  )
+  FetchContent_GetProperties(nudb_src)
+  if(NOT nudb_src_POPULATED)
+    message (STATUS "Pausing to download NuDB...")
+    FetchContent_Populate(nudb_src)
+  endif()
+
+  file(TO_CMAKE_PATH "${nudb_src_SOURCE_DIR}" nudb_src_SOURCE_DIR)
+  # specify as system includes so as to avoid warnings
+  target_include_directories (nudb SYSTEM INTERFACE ${nudb_src_SOURCE_DIR}/include)
+  target_link_libraries (nudb
+    INTERFACE
+      Boost::thread
+      Boost::system)
+  add_library (NIH::nudb ALIAS nudb)
+  target_link_libraries (ripple_libs INTERFACE NIH::nudb)
+endif ()

Builds/CMake/deps/OpenSSL.cmake

@@ -0,0 +1,48 @@
+#[===================================================================[
+   NIH dep: openssl
+#]===================================================================]
+
+#[===============================================[
+  OPENSSL_ROOT_DIR is the only variable that
+  FindOpenSSL honors for locating, so convert any
+  OPENSSL_ROOT vars to this
+#]===============================================]
+if (NOT DEFINED OPENSSL_ROOT_DIR)
+  if (DEFINED ENV{OPENSSL_ROOT})
+    set (OPENSSL_ROOT_DIR $ENV{OPENSSL_ROOT})
+  elseif (HOMEBREW)
+    execute_process (COMMAND ${HOMEBREW} --prefix openssl
+      OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+  endif ()
+  file (TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" OPENSSL_ROOT_DIR)
+endif ()
+
+if (static)
+  set (OPENSSL_USE_STATIC_LIBS ON)
+endif ()
+set (OPENSSL_MSVC_STATIC_RT ON)
+find_package (OpenSSL 1.1.1 REQUIRED)
+target_link_libraries (ripple_libs
+  INTERFACE
+    OpenSSL::SSL
+    OpenSSL::Crypto)
+# disable SSLv2...this can also be done when building/configuring OpenSSL
+set_target_properties(OpenSSL::SSL PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2)
+#[=========================================================[
+   https://gitlab.kitware.com/cmake/cmake/issues/16885
+   depending on how openssl is built, it might depend
+   on zlib. In fact, the openssl find package should
+   figure this out for us, but it does not currently...
+   so let's add zlib ourselves to the lib list
+   TODO: investigate linking to static zlib for static
+   build option
+#]=========================================================]
+find_package (ZLIB)
+set (has_zlib FALSE)
+if (TARGET ZLIB::ZLIB)
+  set_target_properties(OpenSSL::Crypto PROPERTIES
+    INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
+  set (has_zlib TRUE)
+endif ()

Builds/CMake/deps/Postgres.cmake

@@ -0,0 +1,70 @@
+if(reporting)
+    find_package(PostgreSQL)
+    if(NOT PostgreSQL_FOUND)
+        message("find_package did not find postgres")
+        find_library(postgres NAMES pq libpq libpq-dev pq-dev postgresql-devel)
+        find_path(libpq-fe NAMES libpq-fe.h PATH_SUFFIXES postgresql pgsql include)
+
+        if(NOT libpq-fe_FOUND OR NOT postgres_FOUND)
+            message("No system installed Postgres found. Will build")
+            add_library(postgres SHARED IMPORTED GLOBAL)
+            add_library(pgport SHARED IMPORTED GLOBAL)
+            add_library(pgcommon SHARED IMPORTED GLOBAL)
+            ExternalProject_Add(postgres_src
+                PREFIX ${nih_cache_path}
+                GIT_REPOSITORY https://github.com/postgres/postgres.git
+                GIT_TAG REL_14_5
+                CONFIGURE_COMMAND ./configure --without-readline > /dev/null
+                BUILD_COMMAND ${CMAKE_COMMAND} -E env --unset=MAKELEVEL make
+                UPDATE_COMMAND ""
+                BUILD_IN_SOURCE 1
+                INSTALL_COMMAND ""
+                BUILD_BYPRODUCTS
+                    <BINARY_DIR>/src/interfaces/libpq/${ep_lib_prefix}pq.a
+                    <BINARY_DIR>/src/common/${ep_lib_prefix}pgcommon.a
+                    <BINARY_DIR>/src/port/${ep_lib_prefix}pgport.a
+                LOG_BUILD TRUE
+                )
+            ExternalProject_Get_Property (postgres_src SOURCE_DIR)
+            ExternalProject_Get_Property (postgres_src BINARY_DIR)
+
+            set (postgres_src_SOURCE_DIR "${SOURCE_DIR}")
+            file (MAKE_DIRECTORY ${postgres_src_SOURCE_DIR})
+            list(APPEND INCLUDE_DIRS
+                ${SOURCE_DIR}/src/include
+                ${SOURCE_DIR}/src/interfaces/libpq
+                )
+            set_target_properties(postgres PROPERTIES
+                IMPORTED_LOCATION
+                    ${BINARY_DIR}/src/interfaces/libpq/${ep_lib_prefix}pq.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                    "${INCLUDE_DIRS}"
+                )
+            set_target_properties(pgcommon PROPERTIES
+                IMPORTED_LOCATION
+                    ${BINARY_DIR}/src/common/${ep_lib_prefix}pgcommon.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                    "${INCLUDE_DIRS}"
+                )
+            set_target_properties(pgport PROPERTIES
+                IMPORTED_LOCATION
+                    ${BINARY_DIR}/src/port/${ep_lib_prefix}pgport.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                    "${INCLUDE_DIRS}"
+                )
+            add_dependencies(postgres postgres_src)
+            add_dependencies(pgcommon postgres_src)
+            add_dependencies(pgport postgres_src)
+            file(TO_CMAKE_PATH "${postgres_src_SOURCE_DIR}" postgres_src_SOURCE_DIR)
+            target_link_libraries(ripple_libs INTERFACE postgres pgcommon pgport)
+        else()
+            message("Found system installed Postgres via find_libary")
+            target_include_directories(ripple_libs INTERFACE ${libpq-fe})
+            target_link_libraries(ripple_libs INTERFACE ${postgres})
+        endif()
+    else()
+        message("Found system installed Postgres via find_package")
+        target_include_directories(ripple_libs INTERFACE ${PostgreSQL_INCLUDE_DIRS})
+        target_link_libraries(ripple_libs INTERFACE ${PostgreSQL_LIBRARIES})
+    endif()
+endif()

Builds/CMake/deps/Protobuf.cmake

@@ -1,22 +1,156 @@
-find_package(Protobuf 3.8)
+#[===================================================================[
+   import protobuf (lib and compiler) and create a lib
+   from our proto message definitions. If the system protobuf
+   is not found, fallback on EP to download and build a version
+   from official source.
+#]===================================================================]
 
-file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/proto_gen)
+if (static)
+  set (Protobuf_USE_STATIC_LIBS ON)
+endif ()
+find_package (Protobuf 3.8)
+if (is_multiconfig)
+    set(protobuf_protoc_lib ${Protobuf_PROTOC_LIBRARIES})
+else ()
+    string(TOUPPER ${CMAKE_BUILD_TYPE} upper_cmake_build_type)
+    set(protobuf_protoc_lib ${Protobuf_PROTOC_LIBRARY_${upper_cmake_build_type}})
+endif ()
+if (local_protobuf OR NOT (Protobuf_FOUND AND Protobuf_PROTOC_EXECUTABLE AND protobuf_protoc_lib))
+  include (GNUInstallDirs)
+  message (STATUS "using local protobuf build.")
+  set(protobuf_reqs Protobuf_PROTOC_EXECUTABLE protobuf_protoc_lib)
+  foreach(lib ${protobuf_reqs})
+    if(NOT ${lib})
+      message(STATUS "Couldn't find ${lib}")
+    endif()
+  endforeach()
+  if (WIN32)
+    # protobuf prepends lib even on windows
+    set (pbuf_lib_pre "lib")
+  else ()
+    set (pbuf_lib_pre ${ep_lib_prefix})
+  endif ()
+  # for the external project build of protobuf, we currently ignore the
+  # static option and always build static libs here. This is consistent
+  # with our other EP builds. Dynamic libs in an EP would add complexity
+  # because we'd need to get them into the runtime path, and probably
+  # install them.
+  ExternalProject_Add (protobuf_src
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/protocolbuffers/protobuf.git
+    GIT_TAG v3.8.0
+    SOURCE_SUBDIR cmake
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      -DCMAKE_INSTALL_PREFIX=<BINARY_DIR>/_installed_
+      -Dprotobuf_BUILD_TESTS=OFF
+      -Dprotobuf_BUILD_EXAMPLES=OFF
+      -Dprotobuf_BUILD_PROTOC_BINARIES=ON
+      -Dprotobuf_MSVC_STATIC_RUNTIME=ON
+      -DBUILD_SHARED_LIBS=OFF
+      -Dprotobuf_BUILD_SHARED_LIBS=OFF
+      -DCMAKE_DEBUG_POSTFIX=_d
+      -Dprotobuf_DEBUG_POSTFIX=_d
+      -Dprotobuf_WITH_ZLIB=$<IF:$<BOOL:${has_zlib}>,ON,OFF>
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      $<$<BOOL:${MSVC}>:
+	"-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+    TEST_COMMAND ""
+    INSTALL_COMMAND
+      ${CMAKE_COMMAND} -E env --unset=DESTDIR ${CMAKE_COMMAND} --build . --config $<CONFIG> --target install
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protobuf${ep_lib_suffix}
+      <BINARY_DIR>/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protobuf_d${ep_lib_suffix}
+      <BINARY_DIR>/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protoc${ep_lib_suffix}
+      <BINARY_DIR>/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protoc_d${ep_lib_suffix}
+      <BINARY_DIR>/_installed_/bin/protoc${CMAKE_EXECUTABLE_SUFFIX}
+  )
+  ExternalProject_Get_Property (protobuf_src BINARY_DIR)
+  ExternalProject_Get_Property (protobuf_src SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (protobuf_src)
+  endif ()
+  exclude_if_included (protobuf_src)
+
+  if (NOT TARGET protobuf::libprotobuf)
+    add_library (protobuf::libprotobuf STATIC IMPORTED GLOBAL)
+  endif ()
+  file (MAKE_DIRECTORY ${BINARY_DIR}/_installed_/include)
+  set_target_properties (protobuf::libprotobuf PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protobuf_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protobuf${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${BINARY_DIR}/_installed_/include)
+  add_dependencies (protobuf::libprotobuf protobuf_src)
+  exclude_if_included (protobuf::libprotobuf)
+
+  if (NOT TARGET protobuf::libprotoc)
+    add_library (protobuf::libprotoc STATIC IMPORTED GLOBAL)
+  endif ()
+  set_target_properties (protobuf::libprotoc PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protoc_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protoc${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${BINARY_DIR}/_installed_/include)
+  add_dependencies (protobuf::libprotoc protobuf_src)
+  exclude_if_included (protobuf::libprotoc)
+
+  if (NOT TARGET protobuf::protoc)
+    add_executable (protobuf::protoc IMPORTED)
+    exclude_if_included (protobuf::protoc)
+  endif ()
+  set_target_properties (protobuf::protoc PROPERTIES
+    IMPORTED_LOCATION "${BINARY_DIR}/_installed_/bin/protoc${CMAKE_EXECUTABLE_SUFFIX}")
+  add_dependencies (protobuf::protoc protobuf_src)
+else ()
+  if (NOT TARGET protobuf::protoc)
+    if (EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
+      add_executable (protobuf::protoc IMPORTED)
+      set_target_properties (protobuf::protoc PROPERTIES
+        IMPORTED_LOCATION "${Protobuf_PROTOC_EXECUTABLE}")
+    else ()
+      message (FATAL_ERROR "Protobuf import failed")
+    endif ()
+  endif ()
+endif ()
+
+set(output_dir ${CMAKE_BINARY_DIR}/proto_gen)
+file(MAKE_DIRECTORY ${output_dir})
 set(ccbd ${CMAKE_CURRENT_BINARY_DIR})
-set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/proto_gen)
+set(CMAKE_CURRENT_BINARY_DIR ${output_dir})
 protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS src/ripple/proto/ripple.proto)
 set(CMAKE_CURRENT_BINARY_DIR ${ccbd})
 
-add_library(pbufs STATIC ${PROTO_SRCS} ${PROTO_HDRS})
-target_include_directories(pbufs SYSTEM PUBLIC
-  ${CMAKE_BINARY_DIR}/proto_gen
-  ${CMAKE_BINARY_DIR}/proto_gen/src/ripple/proto
+target_include_directories(xrpl_core SYSTEM PUBLIC
+    # The generated implementation imports the header relative to the output
+    # directory.
+    $<BUILD_INTERFACE:${output_dir}>
+    $<BUILD_INTERFACE:${output_dir}/src>
 )
-target_link_libraries(pbufs protobuf::libprotobuf)
-target_compile_options(pbufs
+target_sources(xrpl_core PRIVATE ${output_dir}/src/ripple/proto/ripple.pb.cc)
+install(
+  FILES ${output_dir}/src/ripple/proto/ripple.pb.h
+  DESTINATION include/ripple/proto)
+target_link_libraries(xrpl_core PUBLIC protobuf::libprotobuf)
+target_compile_options(xrpl_core
   PUBLIC
-    $<$<BOOL:${XCODE}>:
+    $<$<BOOL:${is_xcode}>:
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
     >
 )
-add_library(Ripple::pbufs ALIAS pbufs)

Builds/CMake/deps/Rocksdb.cmake

@@ -0,0 +1,177 @@
+#[===================================================================[
+   NIH dep: rocksdb
+#]===================================================================]
+
+add_library (rocksdb_lib UNKNOWN IMPORTED GLOBAL)
+set_target_properties (rocksdb_lib
+  PROPERTIES INTERFACE_COMPILE_DEFINITIONS RIPPLE_ROCKSDB_AVAILABLE=1)
+
+option (local_rocksdb "use local build of rocksdb." OFF)
+if (NOT local_rocksdb)
+  find_package (RocksDB 6.27 QUIET CONFIG)
+  if (TARGET RocksDB::rocksdb)
+    message (STATUS "Found RocksDB using config.")
+    get_target_property (_rockslib_l RocksDB::rocksdb IMPORTED_LOCATION_DEBUG)
+    if (_rockslib_l)
+      set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION_DEBUG ${_rockslib_l})
+    endif ()
+    get_target_property (_rockslib_l RocksDB::rocksdb IMPORTED_LOCATION_RELEASE)
+    if (_rockslib_l)
+      set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION_RELEASE ${_rockslib_l})
+    endif ()
+    get_target_property (_rockslib_l RocksDB::rocksdb IMPORTED_LOCATION)
+    if (_rockslib_l)
+      set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION ${_rockslib_l})
+    endif ()
+    get_target_property (_rockslib_i RocksDB::rocksdb INTERFACE_INCLUDE_DIRECTORIES)
+    if (_rockslib_i)
+      set_target_properties (rocksdb_lib PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${_rockslib_i})
+    endif ()
+    target_link_libraries (ripple_libs INTERFACE RocksDB::rocksdb)
+  else ()
+    # using a find module with rocksdb is difficult because
+    # you have no idea how it was configured (transitive dependencies).
+    # the code below will generally find rocksdb using the module, but
+    # will then result in linker errors for static linkage since the
+    # transitive dependencies are unknown. force local build here for now, but leave the code as
+    # a placeholder for future investigation.
+    if (static)
+      set (local_rocksdb ON CACHE BOOL "" FORCE)
+      # TBD if there is some way to extract transitive deps..then:
+      #set (RocksDB_USE_STATIC ON)
+    else ()
+      find_package (RocksDB 6.27 MODULE)
+      if (ROCKSDB_FOUND)
+        if (RocksDB_LIBRARY_DEBUG)
+          set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION_DEBUG ${RocksDB_LIBRARY_DEBUG})
+        endif ()
+        set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION_RELEASE ${RocksDB_LIBRARIES})
+        set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION ${RocksDB_LIBRARIES})
+        set_target_properties (rocksdb_lib PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${RocksDB_INCLUDE_DIRS})
+      else ()
+        set (local_rocksdb ON CACHE BOOL "" FORCE)
+      endif ()
+    endif ()
+  endif ()
+endif ()
+
+if (local_rocksdb)
+  message (STATUS "Using local build of RocksDB.")
+  ExternalProject_Add (rocksdb
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/facebook/rocksdb.git
+    GIT_TAG v6.27.3
+    PATCH_COMMAND
+      # only used by windows build
+      ${CMAKE_COMMAND} -E copy_if_different
+      ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/rocks_thirdparty.inc
+      <SOURCE_DIR>/thirdparty.inc
+    COMMAND
+      # fixup their build version file to keep the values
+      # from changing always
+      ${CMAKE_COMMAND} -E copy_if_different
+      ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/rocksdb_build_version.cc.in
+      <SOURCE_DIR>/util/build_version.cc.in
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DBUILD_SHARED_LIBS=OFF
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+      -DWITH_JEMALLOC=$<IF:$<BOOL:${jemalloc}>,ON,OFF>
+      -DWITH_SNAPPY=ON
+      -DWITH_LZ4=ON
+      -DWITH_ZLIB=OFF
+      -DUSE_RTTI=ON
+      -DWITH_ZSTD=OFF
+      -DWITH_GFLAGS=OFF
+      -DWITH_BZ2=OFF
+      -ULZ4_*
+      -Ulz4_*
+      -Dlz4_INCLUDE_DIRS=$<JOIN:$<TARGET_PROPERTY:lz4_lib,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -Dlz4_LIBRARIES=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:lz4_lib,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:lz4_lib,IMPORTED_LOCATION_RELEASE>>
+      -Dlz4_FOUND=ON
+      -USNAPPY_*
+      -Usnappy_*
+      -USnappy_*
+      -Dsnappy_INCLUDE_DIRS=$<JOIN:$<TARGET_PROPERTY:snappy_lib,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -Dsnappy_LIBRARIES=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:snappy_lib,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:snappy_lib,IMPORTED_LOCATION_RELEASE>>
+      -Dsnappy_FOUND=ON
+      -DSnappy_INCLUDE_DIRS=$<JOIN:$<TARGET_PROPERTY:snappy_lib,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -DSnappy_LIBRARIES=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:snappy_lib,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:snappy_lib,IMPORTED_LOCATION_RELEASE>>
+      -DSnappy_FOUND=ON
+      -DWITH_MD_LIBRARY=OFF
+      -DWITH_RUNTIME_DEBUG=$<IF:$<CONFIG:Debug>,ON,OFF>
+      -DFAIL_ON_WARNINGS=OFF
+      -DWITH_ASAN=OFF
+      -DWITH_TSAN=OFF
+      -DWITH_UBSAN=OFF
+      -DWITH_NUMA=OFF
+      -DWITH_TBB=OFF
+      -DWITH_WINDOWS_UTF8_FILENAMES=OFF
+      -DWITH_XPRESS=OFF
+      -DPORTABLE=ON
+      -DFORCE_SSE42=OFF
+      -DDISABLE_STALL_NOTIF=OFF
+      -DOPTDBG=ON
+      -DROCKSDB_LITE=OFF
+      -DWITH_FALLOCATE=ON
+      -DWITH_LIBRADOS=OFF
+      -DWITH_JNI=OFF
+      -DROCKSDB_INSTALL_ON_WINDOWS=OFF
+      -DWITH_TESTS=OFF
+      -DWITH_TOOLS=OFF
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -MP /DNDEBUG"
+      >
+      $<$<NOT:$<BOOL:${MSVC}>>:
+        "-DCMAKE_CXX_FLAGS=-DNDEBUG"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+          <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}rocksdb$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>
+        >
+    LIST_SEPARATOR ::
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS snappy_lib lz4_lib
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/${ep_lib_prefix}rocksdb${ep_lib_suffix}
+      <BINARY_DIR>/${ep_lib_prefix}rocksdb_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (rocksdb BINARY_DIR)
+  ExternalProject_Get_Property (rocksdb SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (rocksdb)
+  endif ()
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/include)
+  set_target_properties (rocksdb_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/${ep_lib_prefix}rocksdb_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/${ep_lib_prefix}rocksdb${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR}/include)
+  add_dependencies (rocksdb_lib rocksdb)
+  exclude_if_included (rocksdb)
+endif ()
+
+target_link_libraries (rocksdb_lib
+  INTERFACE
+    snappy_lib
+    lz4_lib
+    $<$<BOOL:${MSVC}>:rpcrt4>)
+exclude_if_included (rocksdb_lib)
+target_link_libraries (ripple_libs INTERFACE rocksdb_lib)

Builds/CMake/deps/Secp256k1.cmake

@@ -0,0 +1,58 @@
+#[===================================================================[
+   NIH dep: secp256k1
+#]===================================================================]
+
+add_library (secp256k1_lib STATIC IMPORTED GLOBAL)
+
+if (NOT WIN32)
+  find_package(secp256k1)
+endif()
+
+if(secp256k1)
+  set_target_properties (secp256k1_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${secp256k1}
+    IMPORTED_LOCATION_RELEASE
+      ${secp256k1}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SECP256K1_INCLUDE_DIR})
+
+  add_library (secp256k1 ALIAS secp256k1_lib)
+  add_library (NIH::secp256k1 ALIAS secp256k1_lib)
+
+else()
+  set(INSTALL_SECP256K1 true)
+
+  add_library (secp256k1 STATIC
+    external/secp256k1/src/secp256k1.c)
+  target_compile_definitions (secp256k1
+    PRIVATE
+      USE_NUM_NONE
+      USE_FIELD_10X26
+      USE_FIELD_INV_BUILTIN
+      USE_SCALAR_8X32
+      USE_SCALAR_INV_BUILTIN)
+  target_include_directories (secp256k1
+    PUBLIC
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/external>
+      $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/external/secp256k1)
+  target_compile_options (secp256k1
+    PRIVATE
+      $<$<BOOL:${MSVC}>:-wd4319>
+      $<$<NOT:$<BOOL:${MSVC}>>:
+        -Wno-deprecated-declarations
+        -Wno-unused-function
+      >
+      $<$<BOOL:${is_gcc}>:-Wno-nonnull-compare>)
+  target_link_libraries (ripple_libs INTERFACE NIH::secp256k1)
+#[===========================[
+     headers installation
+#]===========================]
+  install (
+    FILES
+      external/secp256k1/include/secp256k1.h
+  DESTINATION include/secp256k1/include)
+
+  add_library (NIH::secp256k1 ALIAS secp256k1)
+endif()

Builds/CMake/deps/Snappy.cmake

@@ -0,0 +1,77 @@
+#[===================================================================[
+   NIH dep: snappy
+#]===================================================================]
+
+add_library (snappy_lib STATIC IMPORTED GLOBAL)
+
+if (NOT WIN32)
+  find_package(snappy)
+endif()
+
+if(snappy)
+  set_target_properties (snappy_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${snappy}
+    IMPORTED_LOCATION_RELEASE
+      ${snappy}
+    INTERFACE_INCLUDE_DIRECTORIES
+    ${SNAPPY_INCLUDE_DIR})
+
+else()
+  ExternalProject_Add (snappy
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/google/snappy.git
+    GIT_TAG 1.1.7
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DBUILD_SHARED_LIBS=OFF
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+      -DSNAPPY_BUILD_TESTS=OFF
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
+        "-DCMAKE_CXX_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_CXX_FLAGS_RELEASE=-MT"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+          <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}snappy$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND
+      ${CMAKE_COMMAND} -E copy_if_different <BINARY_DIR>/config.h <BINARY_DIR>/snappy-stubs-public.h <SOURCE_DIR>
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/${ep_lib_prefix}snappy${ep_lib_suffix}
+      <BINARY_DIR>/${ep_lib_prefix}snappy_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (snappy BINARY_DIR)
+  ExternalProject_Get_Property (snappy SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (snappy)
+  endif ()
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/snappy)
+  set_target_properties (snappy_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/${ep_lib_prefix}snappy_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/${ep_lib_prefix}snappy${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR})
+endif()
+
+add_dependencies (snappy_lib snappy)
+target_link_libraries (ripple_libs INTERFACE snappy_lib)
+exclude_if_included (snappy)
+exclude_if_included (snappy_lib)

Builds/CMake/deps/Soci.cmake

@@ -0,0 +1,165 @@
+#[===================================================================[
+   NIH dep: soci
+#]===================================================================]
+
+foreach (_comp core empty sqlite3)
+  add_library ("soci_${_comp}" STATIC IMPORTED GLOBAL)
+endforeach ()
+
+if (NOT WIN32)
+  find_package(soci)
+endif()
+
+if (soci)
+  foreach (_comp core empty sqlite3)
+    set_target_properties ("soci_${_comp}" PROPERTIES
+      IMPORTED_LOCATION_DEBUG
+        ${soci}
+      IMPORTED_LOCATION_RELEASE
+        ${soci}
+      INTERFACE_INCLUDE_DIRECTORIES
+        ${SOCI_INCLUDE_DIR})
+  endforeach ()
+
+else()
+  set (soci_lib_pre ${ep_lib_prefix})
+  set (soci_lib_post "")
+  if (WIN32)
+    # for some reason soci on windows still prepends lib (non-standard)
+    set (soci_lib_pre lib)
+    # this version in the name might change if/when we change versions of soci
+    set (soci_lib_post "_4_0")
+  endif ()
+  get_target_property (_boost_incs Boost::date_time INTERFACE_INCLUDE_DIRECTORIES)
+  get_target_property (_boost_dt Boost::date_time IMPORTED_LOCATION)
+  if (NOT _boost_dt)
+    get_target_property (_boost_dt Boost::date_time IMPORTED_LOCATION_RELEASE)
+  endif ()
+  if (NOT _boost_dt)
+    get_target_property (_boost_dt Boost::date_time IMPORTED_LOCATION_DEBUG)
+  endif ()
+
+  ExternalProject_Add (soci
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/SOCI/soci.git
+    GIT_TAG 04e1870294918d20761736743bb6136314c42dd5
+    # We had an issue with soci integer range checking for boost::optional
+    # and needed to remove the exception that SOCI throws in this case.
+    # This is *probably* a bug in SOCI, but has never been investigated more
+    # nor reported to the maintainers.
+    # This cmake script comments out the lines in question.
+    # This patch process is likely fragile and should be reviewed carefully
+    # whenever we update the GIT_TAG above.
+    PATCH_COMMAND
+      ${CMAKE_COMMAND} -D RIPPLED_SOURCE=${CMAKE_CURRENT_SOURCE_DIR}
+        -P ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/soci_patch.cmake
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      $<$<BOOL:${CMAKE_TOOLCHAIN_FILE}>:-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}>
+      $<$<BOOL:${VCPKG_TARGET_TRIPLET}>:-DVCPKG_TARGET_TRIPLET=${VCPKG_TARGET_TRIPLET}>
+      $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
+      -DCMAKE_PREFIX_PATH=${CMAKE_BINARY_DIR}/sqlite3
+      -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake
+      -DCMAKE_INCLUDE_PATH=$<JOIN:$<TARGET_PROPERTY:sqlite,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -DCMAKE_LIBRARY_PATH=${sqlite_BINARY_DIR}
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DSOCI_CXX_C11=ON
+      -DSOCI_STATIC=ON
+      -DSOCI_LIBDIR=lib
+      -DSOCI_SHARED=OFF
+      -DSOCI_TESTS=OFF
+      # hacks to workaround the fact that soci doesn't currently use
+      # boost imported targets in its cmake. If they switch to
+      # proper imported targets, this next line can be removed
+      # (as well as the get_property above that sets _boost_incs)
+      -DBoost_INCLUDE_DIRS=$<JOIN:${_boost_incs},::>
+      -DBoost_INCLUDE_DIR=$<JOIN:${_boost_incs},::>
+      -DBOOST_ROOT=${BOOST_ROOT}
+      -DWITH_BOOST=ON
+      -DBoost_FOUND=ON
+      -DBoost_NO_BOOST_CMAKE=ON
+      -DBoost_DATE_TIME_FOUND=ON
+      -DSOCI_HAVE_BOOST=ON
+      -DSOCI_HAVE_BOOST_DATE_TIME=ON
+      -DBoost_DATE_TIME_LIBRARY=${_boost_dt}
+      -DSOCI_DB2=OFF
+      -DSOCI_FIREBIRD=OFF
+      -DSOCI_MYSQL=OFF
+      -DSOCI_ODBC=OFF
+      -DSOCI_ORACLE=OFF
+      -DSOCI_POSTGRESQL=OFF
+      -DSOCI_SQLITE3=ON
+      -DSQLITE3_INCLUDE_DIR=$<JOIN:$<TARGET_PROPERTY:sqlite,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -DSQLITE3_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:sqlite,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:sqlite,IMPORTED_LOCATION_RELEASE>>
+      $<$<BOOL:${APPLE}>:-DCMAKE_FIND_FRAMEWORK=LAST>
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
+        "-DCMAKE_CXX_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_CXX_FLAGS_RELEASE=-MT"
+      >
+      $<$<NOT:$<BOOL:${MSVC}>>:
+        "-DCMAKE_CXX_FLAGS=-Wno-deprecated-declarations"
+      >
+      # SEE: https://github.com/SOCI/soci/issues/640
+      $<$<AND:$<BOOL:${is_gcc}>,$<VERSION_GREATER_EQUAL:${CMAKE_CXX_COMPILER_VERSION},8>>:
+        "-DCMAKE_CXX_FLAGS=-Wno-deprecated-declarations -Wno-error=format-overflow -Wno-format-overflow -Wno-error=format-truncation"
+      >
+    LIST_SEPARATOR ::
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+          <BINARY_DIR>/lib/$<CONFIG>/${soci_lib_pre}soci_core${soci_lib_post}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>/lib/$<CONFIG>/${soci_lib_pre}soci_empty${soci_lib_post}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>/lib/$<CONFIG>/${soci_lib_pre}soci_sqlite3${soci_lib_post}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>/lib
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS sqlite
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_core${soci_lib_post}${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_core${soci_lib_post}_d${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_empty${soci_lib_post}${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_empty${soci_lib_post}_d${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_sqlite3${soci_lib_post}${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_sqlite3${soci_lib_post}_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (soci BINARY_DIR)
+  ExternalProject_Get_Property (soci SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (soci)
+  endif ()
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/include)
+  file (MAKE_DIRECTORY ${BINARY_DIR}/include)
+  foreach (_comp core empty sqlite3)
+    set_target_properties ("soci_${_comp}" PROPERTIES
+      IMPORTED_LOCATION_DEBUG
+        ${BINARY_DIR}/lib/${soci_lib_pre}soci_${_comp}${soci_lib_post}_d${ep_lib_suffix}
+      IMPORTED_LOCATION_RELEASE
+        ${BINARY_DIR}/lib/${soci_lib_pre}soci_${_comp}${soci_lib_post}${ep_lib_suffix}
+      INTERFACE_INCLUDE_DIRECTORIES
+        "${SOURCE_DIR}/include;${BINARY_DIR}/include")
+    add_dependencies ("soci_${_comp}" soci) # something has to depend on the ExternalProject to trigger it
+    target_link_libraries (ripple_libs INTERFACE "soci_${_comp}")
+    if (NOT _comp STREQUAL "core")
+      target_link_libraries ("soci_${_comp}" INTERFACE soci_core)
+    endif ()
+  endforeach ()
+endif()
+
+foreach (_comp core empty sqlite3)
+  exclude_if_included ("soci_${_comp}")
+endforeach ()
+
+
+exclude_if_included (soci)

Builds/CMake/deps/Sqlite.cmake

@@ -0,0 +1,93 @@
+#[===================================================================[
+   NIH dep: sqlite
+#]===================================================================]
+
+add_library (sqlite STATIC IMPORTED GLOBAL)
+
+if (NOT WIN32)
+  find_package(sqlite)
+endif()
+
+
+if(sqlite3)
+  set_target_properties (sqlite PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${sqlite3}
+    IMPORTED_LOCATION_RELEASE
+      ${sqlite3}
+    INTERFACE_INCLUDE_DIRECTORIES
+    ${SQLITE_INCLUDE_DIR})
+
+else()
+  ExternalProject_Add (sqlite3
+    PREFIX ${nih_cache_path}
+    # sqlite doesn't use git, but it provides versioned tarballs
+    URL https://www.sqlite.org/2018/sqlite-amalgamation-3260000.zip
+      http://www.sqlite.org/2018/sqlite-amalgamation-3260000.zip
+      https://www2.sqlite.org/2018/sqlite-amalgamation-3260000.zip
+      http://www2.sqlite.org/2018/sqlite-amalgamation-3260000.zip
+    # ^^^ version is apparent in the URL:  3260000 => 3.26.0
+    URL_HASH SHA256=de5dcab133aa339a4cf9e97c40aa6062570086d6085d8f9ad7bc6ddf8a52096e
+    # Don't need to worry about MITM attacks too much because the download
+    # is checked against a strong hash
+    TLS_VERIFY false
+    # we wrote a very simple CMake file to build sqlite
+    # so that's what we copy here so that we can build with
+    # CMake. sqlite doesn't generally provided a build system
+    # for the single amalgamation source file.
+    PATCH_COMMAND
+      ${CMAKE_COMMAND} -E copy_if_different
+      ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/CMake_sqlite3.txt
+      <SOURCE_DIR>/CMakeLists.txt
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_C_FLAGS_RELEASE=-MT"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}sqlite3$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/${ep_lib_prefix}sqlite3${ep_lib_suffix}
+      <BINARY_DIR>/${ep_lib_prefix}sqlite3_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (sqlite3 BINARY_DIR)
+  ExternalProject_Get_Property (sqlite3 SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (sqlite3)
+  endif ()
+
+  set_target_properties (sqlite PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/${ep_lib_prefix}sqlite3_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/${ep_lib_prefix}sqlite3${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR})
+
+  add_dependencies (sqlite sqlite3)
+  exclude_if_included (sqlite3)
+endif()
+
+target_link_libraries (sqlite INTERFACE $<$<NOT:$<BOOL:${MSVC}>>:dl>)
+target_link_libraries (ripple_libs INTERFACE sqlite)
+exclude_if_included (sqlite)
+set(sqlite_BINARY_DIR ${BINARY_DIR})

Builds/CMake/deps/WasmEdge.cmake

@@ -81,4 +81,4 @@ if(XAR_LIBRARY)
 else()
   message(WARNING "xar library not found... (only important for mac builds)")
 endif()
-add_library (NIH::WasmEdge ALIAS wasmedge)
+add_library (wasmedge::wasmedge ALIAS wasmedge)

Builds/CMake/deps/cassandra.cmake

@@ -0,0 +1,167 @@
+if(reporting)
+    find_library(cassandra NAMES cassandra)
+    if(NOT cassandra)
+
+        message("System installed Cassandra cpp driver not found. Will build")
+
+        find_library(zlib NAMES zlib1g-dev zlib-devel zlib z)
+        if(NOT zlib)
+            message("zlib not found. will build")
+            add_library(zlib STATIC IMPORTED GLOBAL)
+            ExternalProject_Add(zlib_src
+                PREFIX ${nih_cache_path}
+                GIT_REPOSITORY https://github.com/madler/zlib.git
+                GIT_TAG v1.2.12
+                INSTALL_COMMAND ""
+                BUILD_BYPRODUCTS <BINARY_DIR>/${ep_lib_prefix}z.a
+                LOG_BUILD TRUE
+                LOG_CONFIGURE TRUE
+                )
+
+
+            ExternalProject_Get_Property (zlib_src SOURCE_DIR)
+            ExternalProject_Get_Property (zlib_src BINARY_DIR)
+            set (zlib_src_SOURCE_DIR "${SOURCE_DIR}")
+            file (MAKE_DIRECTORY ${zlib_src_SOURCE_DIR}/include)
+
+            set_target_properties (zlib PROPERTIES
+                IMPORTED_LOCATION
+                ${BINARY_DIR}/${ep_lib_prefix}z.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                ${SOURCE_DIR}/include)
+            add_dependencies(zlib zlib_src)
+
+            file(TO_CMAKE_PATH "${zlib_src_SOURCE_DIR}" zlib_src_SOURCE_DIR)
+        endif()
+
+
+
+
+        find_library(krb5 NAMES krb5-dev libkrb5-dev)
+
+        if(NOT krb5)
+            message("krb5 not found. will build")
+            add_library(krb5 STATIC IMPORTED GLOBAL)
+            ExternalProject_Add(krb5_src
+                PREFIX ${nih_cache_path}
+                GIT_REPOSITORY https://github.com/krb5/krb5.git
+                GIT_TAG krb5-1.20-final
+                UPDATE_COMMAND ""
+                CONFIGURE_COMMAND autoreconf src && CFLAGS=-fcommon ./src/configure --enable-static --disable-shared > /dev/null
+                BUILD_IN_SOURCE 1
+                BUILD_COMMAND make
+                INSTALL_COMMAND ""
+                BUILD_BYPRODUCTS <SOURCE_DIR>/lib/${ep_lib_prefix}krb5.a
+                LOG_BUILD TRUE
+                )
+
+            ExternalProject_Get_Property (krb5_src SOURCE_DIR)
+            ExternalProject_Get_Property (krb5_src BINARY_DIR)
+            set (krb5_src_SOURCE_DIR "${SOURCE_DIR}")
+            file (MAKE_DIRECTORY ${krb5_src_SOURCE_DIR}/include)
+
+            set_target_properties (krb5 PROPERTIES
+                IMPORTED_LOCATION
+                ${BINARY_DIR}/lib/${ep_lib_prefix}krb5.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                ${SOURCE_DIR}/include)
+            add_dependencies(krb5 krb5_src)
+
+            file(TO_CMAKE_PATH "${krb5_src_SOURCE_DIR}" krb5_src_SOURCE_DIR)
+        endif()
+
+
+        find_library(libuv1 NAMES uv1 libuv1 liubuv1-dev libuv1:amd64)
+
+
+        if(NOT libuv1)
+            message("libuv1 not found, will build")
+            add_library(libuv1 STATIC IMPORTED GLOBAL)
+            ExternalProject_Add(libuv_src
+                PREFIX ${nih_cache_path}
+                GIT_REPOSITORY https://github.com/libuv/libuv.git
+                GIT_TAG v1.44.2
+                INSTALL_COMMAND ""
+                BUILD_BYPRODUCTS <BINARY_DIR>/${ep_lib_prefix}uv_a.a
+                LOG_BUILD TRUE
+                LOG_CONFIGURE TRUE
+                )
+
+            ExternalProject_Get_Property (libuv_src SOURCE_DIR)
+            ExternalProject_Get_Property (libuv_src BINARY_DIR)
+            set (libuv_src_SOURCE_DIR "${SOURCE_DIR}")
+            file (MAKE_DIRECTORY ${libuv_src_SOURCE_DIR}/include)
+
+            set_target_properties (libuv1 PROPERTIES
+                IMPORTED_LOCATION
+                ${BINARY_DIR}/${ep_lib_prefix}uv_a.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                ${SOURCE_DIR}/include)
+            add_dependencies(libuv1 libuv_src)
+
+            file(TO_CMAKE_PATH "${libuv_src_SOURCE_DIR}" libuv_src_SOURCE_DIR)
+        endif()
+
+        add_library (cassandra STATIC IMPORTED GLOBAL)
+        ExternalProject_Add(cassandra_src
+            PREFIX ${nih_cache_path}
+            GIT_REPOSITORY https://github.com/datastax/cpp-driver.git
+            GIT_TAG 2.16.2
+            CMAKE_ARGS
+            -DLIBUV_ROOT_DIR=${BINARY_DIR}
+            -DLIBUV_LIBARY=${BINARY_DIR}/libuv_a.a
+            -DLIBUV_INCLUDE_DIR=${SOURCE_DIR}/include
+            -DCASS_BUILD_STATIC=ON
+            -DCASS_BUILD_SHARED=OFF
+            -DOPENSSL_ROOT_DIR=/opt/local/openssl
+            INSTALL_COMMAND ""
+            BUILD_BYPRODUCTS <BINARY_DIR>/${ep_lib_prefix}cassandra_static.a
+            LOG_BUILD TRUE
+            LOG_CONFIGURE TRUE
+            )
+
+        ExternalProject_Get_Property (cassandra_src SOURCE_DIR)
+        ExternalProject_Get_Property (cassandra_src BINARY_DIR)
+        set (cassandra_src_SOURCE_DIR "${SOURCE_DIR}")
+        file (MAKE_DIRECTORY ${cassandra_src_SOURCE_DIR}/include)
+
+        set_target_properties (cassandra PROPERTIES
+            IMPORTED_LOCATION
+            ${BINARY_DIR}/${ep_lib_prefix}cassandra_static.a
+            INTERFACE_INCLUDE_DIRECTORIES
+            ${SOURCE_DIR}/include)
+        add_dependencies(cassandra cassandra_src)
+
+        if(NOT libuv1)
+            ExternalProject_Add_StepDependencies(cassandra_src build libuv1)
+            target_link_libraries(cassandra INTERFACE libuv1)
+        else()
+            target_link_libraries(cassandra INTERFACE ${libuv1})
+        endif()
+        if(NOT krb5)
+
+            ExternalProject_Add_StepDependencies(cassandra_src build krb5)
+            target_link_libraries(cassandra INTERFACE krb5)
+        else()
+            target_link_libraries(cassandra INTERFACE ${krb5})
+        endif()
+
+        if(NOT zlib)
+            ExternalProject_Add_StepDependencies(cassandra_src build zlib)
+            target_link_libraries(cassandra INTERFACE zlib)
+        else()
+            target_link_libraries(cassandra INTERFACE ${zlib})
+        endif()
+
+        file(TO_CMAKE_PATH "${cassandra_src_SOURCE_DIR}" cassandra_src_SOURCE_DIR)
+        target_link_libraries(ripple_libs INTERFACE cassandra)
+    else()
+        message("Found system installed cassandra cpp driver")
+
+        find_path(cassandra_includes NAMES cassandra.h REQUIRED)
+        target_link_libraries (ripple_libs INTERFACE ${cassandra})
+        target_include_directories(ripple_libs INTERFACE ${cassandra_includes})
+    endif()
+
+    exclude_if_included (cassandra)
+endif()

Builds/CMake/deps/date.cmake

@@ -0,0 +1,18 @@
+#[===================================================================[
+   NIH dep: date
+
+   the main library is header-only, thus is an INTERFACE lib in CMake.
+
+   NOTE: this has been accepted into c++20 so can likely be replaced
+   when we update to that standard
+#]===================================================================]
+
+find_package (date QUIET)
+if (NOT TARGET date::date)
+  FetchContent_Declare(
+    hh_date_src
+    GIT_REPOSITORY https://github.com/HowardHinnant/date.git
+    GIT_TAG        fc4cf092f9674f2670fb9177edcdee870399b829
+  )
+  FetchContent_MakeAvailable(hh_date_src)
+endif ()

Builds/CMake/deps/gRPC.cmake

@@ -1,23 +1,340 @@
-find_package(gRPC 1.23)
+
+# currently linking to unsecure versions...if we switch, we'll
+# need to add ssl as a link dependency to the grpc targets
+option (use_secure_grpc "use TLS version of grpc libs." OFF)
+if (use_secure_grpc)
+  set (grpc_suffix "")
+else ()
+  set (grpc_suffix "_unsecure")
+endif ()
+
+find_package (gRPC 1.23 CONFIG QUIET)
+if (TARGET gRPC::gpr AND NOT local_grpc)
+  get_target_property (_grpc_l gRPC::gpr IMPORTED_LOCATION_DEBUG)
+  if (NOT _grpc_l)
+    get_target_property (_grpc_l gRPC::gpr IMPORTED_LOCATION_RELEASE)
+  endif ()
+  if (NOT _grpc_l)
+    get_target_property (_grpc_l gRPC::gpr IMPORTED_LOCATION)
+  endif ()
+  message (STATUS "Found cmake config for gRPC. Using ${_grpc_l}.")
+else ()
+  find_package (PkgConfig QUIET)
+  if (PKG_CONFIG_FOUND)
+    pkg_check_modules (grpc QUIET "grpc${grpc_suffix}>=1.25" "grpc++${grpc_suffix}" gpr)
+  endif ()
+
+  if (grpc_FOUND)
+    message (STATUS "Found gRPC using pkg-config. Using ${grpc_gpr_PREFIX}.")
+  endif ()
+
+  add_executable (gRPC::grpc_cpp_plugin IMPORTED)
+  exclude_if_included (gRPC::grpc_cpp_plugin)
+
+  if (grpc_FOUND AND NOT local_grpc)
+    # use installed grpc (via pkg-config)
+    macro (add_imported_grpc libname_)
+      if (static)
+        set (_search "${CMAKE_STATIC_LIBRARY_PREFIX}${libname_}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+      else ()
+        set (_search "${CMAKE_SHARED_LIBRARY_PREFIX}${libname_}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+      endif()
+      find_library(_found_${libname_}
+        NAMES ${_search}
+        HINTS ${grpc_LIBRARY_DIRS})
+      if (_found_${libname_})
+        message (STATUS "importing ${libname_} as ${_found_${libname_}}")
+      else ()
+        message (FATAL_ERROR "using pkg-config for grpc, can't find ${_search}")
+      endif ()
+      add_library ("gRPC::${libname_}" STATIC IMPORTED GLOBAL)
+      set_target_properties ("gRPC::${libname_}" PROPERTIES IMPORTED_LOCATION ${_found_${libname_}})
+      if (grpc_INCLUDE_DIRS)
+        set_target_properties ("gRPC::${libname_}" PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${grpc_INCLUDE_DIRS})
+      endif ()
+      target_link_libraries (ripple_libs INTERFACE "gRPC::${libname_}")
+      exclude_if_included ("gRPC::${libname_}")
+    endmacro ()
+
+    set_target_properties (gRPC::grpc_cpp_plugin PROPERTIES
+        IMPORTED_LOCATION "${grpc_gpr_PREFIX}/bin/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}")
+
+    pkg_check_modules (cares QUIET libcares)
+    if (cares_FOUND)
+      if (static)
+        set (_search "${CMAKE_STATIC_LIBRARY_PREFIX}cares${CMAKE_STATIC_LIBRARY_SUFFIX}")
+        set (_prefix cares_STATIC)
+        set (_static STATIC)
+      else ()
+        set (_search "${CMAKE_SHARED_LIBRARY_PREFIX}cares${CMAKE_SHARED_LIBRARY_SUFFIX}")
+        set (_prefix cares)
+        set (_static)
+      endif()
+      find_library(_location NAMES ${_search} HINTS ${cares_LIBRARY_DIRS})
+      if (NOT _location)
+        message (FATAL_ERROR "using pkg-config for grpc, can't find c-ares")
+      endif ()
+      if(${_location} MATCHES "\\.a$")
+        add_library(c-ares::cares STATIC IMPORTED GLOBAL)
+      else()
+        add_library(c-ares::cares SHARED IMPORTED GLOBAL)
+      endif()      
+      set_target_properties (c-ares::cares PROPERTIES
+        IMPORTED_LOCATION ${_location}
+        INTERFACE_INCLUDE_DIRECTORIES "${${_prefix}_INCLUDE_DIRS}"
+        INTERFACE_LINK_OPTIONS "${${_prefix}_LDFLAGS}"
+      )
+      exclude_if_included (c-ares::cares)
+    else ()
+      message (FATAL_ERROR "using pkg-config for grpc, can't find c-ares")
+    endif ()
+  else ()
+    #[===========================[
+       c-ares (grpc requires)
+    #]===========================]
+    ExternalProject_Add (c-ares_src
+      PREFIX ${nih_cache_path}
+      GIT_REPOSITORY https://github.com/c-ares/c-ares.git
+      GIT_TAG cares-1_15_0
+      CMAKE_ARGS
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+        -DCMAKE_DEBUG_POSTFIX=_d
+        $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+        -DCMAKE_INSTALL_PREFIX=<BINARY_DIR>/_installed_
+        -DCARES_SHARED=OFF
+        -DCARES_STATIC=ON
+        -DCARES_STATIC_PIC=ON
+        -DCARES_INSTALL=ON
+        -DCARES_MSVC_STATIC_RUNTIME=ON
+        $<$<BOOL:${MSVC}>:
+          "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        >
+      LOG_BUILD ON
+      LOG_CONFIGURE ON
+      BUILD_COMMAND
+        ${CMAKE_COMMAND}
+          --build .
+          --config $<CONFIG>
+          --parallel ${ep_procs}
+      TEST_COMMAND ""
+      INSTALL_COMMAND
+        ${CMAKE_COMMAND} -E env --unset=DESTDIR ${CMAKE_COMMAND} --build . --config $<CONFIG> --target install
+      BUILD_BYPRODUCTS
+        <BINARY_DIR>/_installed_/lib/${ep_lib_prefix}cares${ep_lib_suffix}
+        <BINARY_DIR>/_installed_/lib/${ep_lib_prefix}cares_d${ep_lib_suffix}
+    )
+    exclude_if_included (c-ares_src)
+    ExternalProject_Get_Property (c-ares_src BINARY_DIR)
+    set (cares_binary_dir "${BINARY_DIR}")
+
+    add_library (c-ares::cares STATIC IMPORTED GLOBAL)
+    file (MAKE_DIRECTORY ${BINARY_DIR}/_installed_/include)
+    set_target_properties (c-ares::cares PROPERTIES
+      IMPORTED_LOCATION_DEBUG
+        ${BINARY_DIR}/_installed_/lib/${ep_lib_prefix}cares_d${ep_lib_suffix}
+      IMPORTED_LOCATION_RELEASE
+        ${BINARY_DIR}/_installed_/lib/${ep_lib_prefix}cares${ep_lib_suffix}
+      INTERFACE_INCLUDE_DIRECTORIES
+        ${BINARY_DIR}/_installed_/include)
+    add_dependencies (c-ares::cares c-ares_src)
+    exclude_if_included (c-ares::cares)
+
+    if (NOT has_zlib)
+      #[===========================[
+         zlib (grpc requires)
+      #]===========================]
+      if (MSVC)
+        set (zlib_debug_postfix "d") # zlib cmake sets this internally for MSVC, so we really don't have a choice
+        set (zlib_base "zlibstatic")
+      else ()
+        set (zlib_debug_postfix "_d")
+        set (zlib_base "z")
+      endif ()
+      ExternalProject_Add (zlib_src
+        PREFIX ${nih_cache_path}
+        GIT_REPOSITORY https://github.com/madler/zlib.git
+        GIT_TAG v1.2.11
+        CMAKE_ARGS
+          -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+          $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+          -DCMAKE_DEBUG_POSTFIX=${zlib_debug_postfix}
+          $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+          -DCMAKE_INSTALL_PREFIX=<BINARY_DIR>/_installed_
+          -DBUILD_SHARED_LIBS=OFF
+          $<$<BOOL:${MSVC}>:
+            "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+            "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+            "-DCMAKE_C_FLAGS_RELEASE=-MT"
+          >
+        LOG_BUILD ON
+        LOG_CONFIGURE ON
+        BUILD_COMMAND
+          ${CMAKE_COMMAND}
+            --build .
+            --config $<CONFIG>
+            --parallel ${ep_procs}
+        TEST_COMMAND ""
+        INSTALL_COMMAND
+          ${CMAKE_COMMAND} -E env --unset=DESTDIR ${CMAKE_COMMAND} --build . --config $<CONFIG> --target install
+        BUILD_BYPRODUCTS
+          <BINARY_DIR>/_installed_/lib/${ep_lib_prefix}${zlib_base}${ep_lib_suffix}
+          <BINARY_DIR>/_installed_/lib/${ep_lib_prefix}${zlib_base}${zlib_debug_postfix}${ep_lib_suffix}
+      )
+      exclude_if_included (zlib_src)
+      ExternalProject_Get_Property (zlib_src BINARY_DIR)
+      set (zlib_binary_dir "${BINARY_DIR}")
+
+      add_library (ZLIB::ZLIB STATIC IMPORTED GLOBAL)
+      file (MAKE_DIRECTORY ${BINARY_DIR}/_installed_/include)
+      set_target_properties (ZLIB::ZLIB PROPERTIES
+        IMPORTED_LOCATION_DEBUG
+          ${BINARY_DIR}/_installed_/lib/${ep_lib_prefix}${zlib_base}${zlib_debug_postfix}${ep_lib_suffix}
+        IMPORTED_LOCATION_RELEASE
+          ${BINARY_DIR}/_installed_/lib/${ep_lib_prefix}${zlib_base}${ep_lib_suffix}
+        INTERFACE_INCLUDE_DIRECTORIES
+          ${BINARY_DIR}/_installed_/include)
+      add_dependencies (ZLIB::ZLIB zlib_src)
+      exclude_if_included (ZLIB::ZLIB)
+    endif ()
+
+    #[===========================[
+       grpc
+    #]===========================]
+    ExternalProject_Add (grpc_src
+      PREFIX ${nih_cache_path}
+      GIT_REPOSITORY https://github.com/grpc/grpc.git
+      GIT_TAG v1.25.0
+      CMAKE_ARGS
+        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_STANDARD=17
+        $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+        $<$<BOOL:${CMAKE_TOOLCHAIN_FILE}>:-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}>
+        $<$<BOOL:${VCPKG_TARGET_TRIPLET}>:-DVCPKG_TARGET_TRIPLET=${VCPKG_TARGET_TRIPLET}>
+        $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
+        -DCMAKE_DEBUG_POSTFIX=_d
+        $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+        -DgRPC_BUILD_TESTS=OFF
+        -DgRPC_BENCHMARK_PROVIDER=""
+        -DgRPC_BUILD_CSHARP_EXT=OFF
+        -DgRPC_MSVC_STATIC_RUNTIME=ON
+        -DgRPC_INSTALL=OFF
+        -DgRPC_CARES_PROVIDER=package
+        -Dc-ares_DIR=${cares_binary_dir}/_installed_/lib/cmake/c-ares
+        -DgRPC_SSL_PROVIDER=package
+        -DOPENSSL_ROOT_DIR=${OPENSSL_ROOT_DIR}
+        -DgRPC_PROTOBUF_PROVIDER=package
+        -DProtobuf_USE_STATIC_LIBS=$<IF:$<AND:$<BOOL:${Protobuf_FOUND}>,$<NOT:$<BOOL:${static}>>>,OFF,ON>
+        -DProtobuf_INCLUDE_DIR=$<JOIN:$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>,:_:>
+        -DProtobuf_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:protobuf::libprotobuf,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:protobuf::libprotobuf,IMPORTED_LOCATION_RELEASE>>
+        -DProtobuf_PROTOC_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:protobuf::libprotoc,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:protobuf::libprotoc,IMPORTED_LOCATION_RELEASE>>
+        -DProtobuf_PROTOC_EXECUTABLE=$<TARGET_PROPERTY:protobuf::protoc,IMPORTED_LOCATION>
+        -DgRPC_ZLIB_PROVIDER=package
+        $<$<NOT:$<BOOL:${has_zlib}>>:-DZLIB_ROOT=${zlib_binary_dir}/_installed_>
+        $<$<BOOL:${MSVC}>:
+          "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
+          "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        >
+      LOG_BUILD ON
+      LOG_CONFIGURE ON
+      BUILD_COMMAND
+        ${CMAKE_COMMAND}
+        --build .
+        --config $<CONFIG>
+        --parallel ${ep_procs}
+        $<$<BOOL:${is_multiconfig}>:
+          COMMAND
+            ${CMAKE_COMMAND} -E copy
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}grpc${grpc_suffix}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}grpc++${grpc_suffix}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}address_sorting$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}gpr$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/$<CONFIG>/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}
+            <BINARY_DIR>
+          >
+      LIST_SEPARATOR :_:
+      TEST_COMMAND ""
+      INSTALL_COMMAND ""
+      DEPENDS c-ares_src
+      BUILD_BYPRODUCTS
+        <BINARY_DIR>/${ep_lib_prefix}grpc${grpc_suffix}${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}grpc${grpc_suffix}_d${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}grpc++${grpc_suffix}${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}grpc++${grpc_suffix}_d${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}address_sorting${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}address_sorting_d${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}gpr${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}gpr_d${ep_lib_suffix}
+        <BINARY_DIR>/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}
+    )
+    if (TARGET protobuf_src)
+      ExternalProject_Add_StepDependencies(grpc_src build protobuf_src)
+    endif ()
+    exclude_if_included (grpc_src)
+    ExternalProject_Get_Property (grpc_src BINARY_DIR)
+    ExternalProject_Get_Property (grpc_src SOURCE_DIR)
+    set (grpc_binary_dir "${BINARY_DIR}")
+    set (grpc_source_dir "${SOURCE_DIR}")
+    if (CMAKE_VERBOSE_MAKEFILE)
+      print_ep_logs (grpc_src)
+    endif ()
+    file (MAKE_DIRECTORY ${SOURCE_DIR}/include)
+
+    macro (add_imported_grpc libname_)
+      add_library ("gRPC::${libname_}" STATIC IMPORTED GLOBAL)
+      set_target_properties ("gRPC::${libname_}" PROPERTIES
+        IMPORTED_LOCATION_DEBUG
+          ${grpc_binary_dir}/${ep_lib_prefix}${libname_}_d${ep_lib_suffix}
+        IMPORTED_LOCATION_RELEASE
+          ${grpc_binary_dir}/${ep_lib_prefix}${libname_}${ep_lib_suffix}
+        INTERFACE_INCLUDE_DIRECTORIES
+          ${grpc_source_dir}/include)
+      add_dependencies ("gRPC::${libname_}" grpc_src)
+      target_link_libraries (ripple_libs INTERFACE "gRPC::${libname_}")
+      exclude_if_included ("gRPC::${libname_}")
+    endmacro ()
+
+    set_target_properties (gRPC::grpc_cpp_plugin PROPERTIES
+        IMPORTED_LOCATION "${grpc_binary_dir}/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}")
+    add_dependencies (gRPC::grpc_cpp_plugin grpc_src)
+  endif ()
+
+  add_imported_grpc (gpr)
+  add_imported_grpc ("grpc${grpc_suffix}")
+  add_imported_grpc ("grpc++${grpc_suffix}")
+  add_imported_grpc (address_sorting)
+
+  target_link_libraries ("gRPC::grpc${grpc_suffix}" INTERFACE c-ares::cares gRPC::gpr gRPC::address_sorting ZLIB::ZLIB)
+  target_link_libraries ("gRPC::grpc++${grpc_suffix}" INTERFACE "gRPC::grpc${grpc_suffix}" gRPC::gpr)
+endif ()
 
 #[=================================[
    generate protobuf sources for
    grpc defs and bundle into a
    static lib
 #]=================================]
-set(GRPC_GEN_DIR "${CMAKE_BINARY_DIR}/proto_gen_grpc")
+set(output_dir "${CMAKE_BINARY_DIR}/proto_gen_grpc")
+set(GRPC_GEN_DIR "${output_dir}/ripple/proto")
 file(MAKE_DIRECTORY ${GRPC_GEN_DIR})
 set(GRPC_PROTO_SRCS)
 set(GRPC_PROTO_HDRS)
 set(GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
-file(GLOB_RECURSE GRPC_DEFINITION_FILES LIST_DIRECTORIES false "${GRPC_PROTO_ROOT}/*.proto")
+file(GLOB_RECURSE GRPC_DEFINITION_FILES "${GRPC_PROTO_ROOT}/*.proto")
 foreach(file ${GRPC_DEFINITION_FILES})
+  # /home/user/rippled/src/ripple/proto/org/.../v1/get_ledger.proto
   get_filename_component(_abs_file ${file} ABSOLUTE)
+  # /home/user/rippled/src/ripple/proto/org/.../v1
   get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
+  # get_ledger
   get_filename_component(_basename ${file} NAME_WE)
+  # /home/user/rippled/src/ripple/proto
   get_filename_component(_proto_inc ${GRPC_PROTO_ROOT} DIRECTORY) # updir one level
+  # org/.../v1/get_ledger.proto
   file(RELATIVE_PATH _rel_root_file ${_proto_inc} ${_abs_file})
+  # org/.../v1
   get_filename_component(_rel_root_dir ${_rel_root_file} DIRECTORY)
+  # src/ripple/proto/org/.../v1
   file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir})
 
   set(src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
@@ -36,27 +353,40 @@ foreach(file ${GRPC_DEFINITION_FILES})
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     COMMENT "Running gRPC C++ protocol buffer compiler on ${file}"
     VERBATIM)
-    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES GENERATED TRUE)
+    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES
+      GENERATED TRUE
+      SKIP_UNITY_BUILD_INCLUSION ON
+    )
     list(APPEND GRPC_PROTO_SRCS ${src_1} ${src_2})
     list(APPEND GRPC_PROTO_HDRS ${hdr_1} ${hdr_2})
 endforeach()
 
-add_library(grpc_pbufs STATIC ${GRPC_PROTO_SRCS} ${GRPC_PROTO_HDRS})
-#target_include_directories(grpc_pbufs PRIVATE src)
-target_include_directories(grpc_pbufs SYSTEM PUBLIC ${GRPC_GEN_DIR})
-target_link_libraries(grpc_pbufs
+target_include_directories(xrpl_core SYSTEM PUBLIC
+  $<BUILD_INTERFACE:${output_dir}>
+  $<BUILD_INTERFACE:${output_dir}/ripple/proto>
+  # The generated sources include headers relative to this path. Fix it later.
+  $<INSTALL_INTERFACE:include/ripple/proto>
+)
+target_sources(xrpl_core PRIVATE ${GRPC_PROTO_SRCS})
+install(
+  DIRECTORY ${output_dir}/ripple
+  DESTINATION include/
+  FILES_MATCHING PATTERN "*.h"
+)
+target_link_libraries(xrpl_core PUBLIC
   "gRPC::grpc++"
   # libgrpc is missing references.
   absl::random_random
 )
-target_compile_options(grpc_pbufs
+target_compile_options(xrpl_core
   PRIVATE
     $<$<BOOL:${MSVC}>:-wd4065>
     $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
   PUBLIC
     $<$<BOOL:${MSVC}>:-wd4996>
-    $<$<BOOL:${XCODE}>:
+    $<$<BOOL:${is_xcode}>:
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
     >)
-add_library(Ripple::grpc_pbufs ALIAS grpc_pbufs)
+# target_link_libraries (ripple_libs INTERFACE Ripple::grpc_pbufs)
+# exclude_if_included (grpc_pbufs)

Builds/CMake/echo_file.cmake

@@ -1,17 +0,0 @@
-#[=========================================================[
-  This is a CMake script file that is used to write
-  the contents of a file to stdout (using the cmake
-  echo command). The input file is passed via the
-  IN_FILE variable.
-#]=========================================================]
-
-if (EXISTS ${IN_FILE})
-  file (READ ${IN_FILE} contents)
-  ## only print files that actually have some text in them
-  if (contents MATCHES "[a-z0-9A-Z]+")
-    execute_process(
-      COMMAND
-        ${CMAKE_COMMAND} -E echo "${contents}")
-  endif ()
-endif ()
-

Builds/CMake/rocks_thirdparty.inc

@@ -0,0 +1,15 @@
+set (THIRDPARTY_LIBS "")
+
+if(WITH_SNAPPY)
+  add_definitions(-DSNAPPY)
+  include_directories(${snappy_INCLUDE_DIRS})
+  set (THIRDPARTY_LIBS ${THIRDPARTY_LIBS} ${snappy_LIBRARIES})
+endif()
+
+if(WITH_LZ4)
+  add_definitions(-DLZ4)
+  include_directories(${lz4_INCLUDE_DIRS})
+  set (THIRDPARTY_LIBS ${THIRDPARTY_LIBS} ${lz4_LIBRARIES})
+endif()
+
+

Builds/CMake/rocksdb_build_version.cc.in

@@ -0,0 +1,71 @@
+// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+#include <memory>
+
+#include "rocksdb/version.h"
+#include "util/string_util.h"
+
+// The build script may replace these values with real values based
+// on whether or not GIT is available and the platform settings
+static const std::string rocksdb_build_git_sha  = "rocksdb_build_git_sha:@GIT_SHA@";
+static const std::string rocksdb_build_git_tag = "rocksdb_build_git_tag:@GIT_TAG@";
+#define HAS_GIT_CHANGES @GIT_MOD@
+#if HAS_GIT_CHANGES == 0
+// If HAS_GIT_CHANGES is 0, the GIT date is used.
+// Use the time the branch/tag was last modified
+static const std::string rocksdb_build_date = "rocksdb_build_date:@GIT_DATE@";
+#else
+// If HAS_GIT_CHANGES is > 0, the branch/tag has modifications.
+// Use the time the build was created.
+static const std::string rocksdb_build_date = "rocksdb_build_date:@BUILD_DATE@";
+#endif
+
+namespace ROCKSDB_NAMESPACE {
+static void AddProperty(std::unordered_map<std::string, std::string> *props, const std::string& name) {
+  size_t colon = name.find(":");
+  if (colon != std::string::npos && colon > 0 && colon < name.length() - 1) {
+    // If we found a "@:", then this property was a build-time substitution that failed.  Skip it
+    size_t at = name.find("@", colon);
+    if (at != colon + 1) {
+      // Everything before the colon is the name, after is the value
+      (*props)[name.substr(0, colon)] = name.substr(colon + 1);
+    }
+  }
+}
+  
+static std::unordered_map<std::string, std::string>* LoadPropertiesSet() {
+  auto * properties = new std::unordered_map<std::string, std::string>();
+  AddProperty(properties, rocksdb_build_git_sha);
+  AddProperty(properties, rocksdb_build_git_tag);
+  AddProperty(properties, rocksdb_build_date);
+  return properties;
+}
+
+const std::unordered_map<std::string, std::string>& GetRocksBuildProperties() {
+  static std::unique_ptr<std::unordered_map<std::string, std::string>> props(LoadPropertiesSet());
+  return *props;
+}
+
+std::string GetRocksVersionAsString(bool with_patch) {
+  std::string version = ToString(ROCKSDB_MAJOR) + "." + ToString(ROCKSDB_MINOR);
+  if (with_patch) {
+    return version + "." + ToString(ROCKSDB_PATCH);
+  } else {
+    return version;
+  }
+}
+  
+std::string GetRocksBuildInfoAsString(const std::string& program, bool verbose) {
+  std::string info = program + " (RocksDB) " + GetRocksVersionAsString(true);
+  if (verbose) {
+    for (const auto& it : GetRocksBuildProperties()) {
+      info.append("\n    ");
+      info.append(it.first);
+      info.append(": ");
+      info.append(it.second);
+    }
+  }
+  return info;
+}
+} // namespace ROCKSDB_NAMESPACE
+

Builds/CMake/soci_patch.cmake

@@ -0,0 +1,49 @@
+# This patches unsigned-types.h in the soci official sources
+# so as to remove type range check exceptions that cause
+# us trouble when using boost::optional to select int values
+
+# Soci's CMake setup leaves flags in place that will cause warnings to
+# be treated as errors, but some compiler versions throw "new" warnings
+# that then cause the build to fail. Simplify that until soci fixes
+# those warnings.
+if (RIPPLED_SOURCE)
+  execute_process( COMMAND ${CMAKE_COMMAND} -E copy_if_different
+      ${RIPPLED_SOURCE}/Builds/CMake/SociConfig.cmake.patched
+      cmake/SociConfig.cmake )
+endif ()
+
+# Some versions of CMake erroneously patch external projects on every build.
+# If the patch makes no changes, skip it. This workaround can be
+# removed once we stop supporting vulnerable versions of CMake.
+# https://gitlab.kitware.com/cmake/cmake/-/issues/21086
+file (STRINGS include/soci/unsigned-types.h sourcecode)
+# Delete the .patched file if it exists, so it doesn't end up duplicated.
+# Trying to remove a file that does not exist is not a problem.
+file (REMOVE include/soci/unsigned-types.h.patched)
+foreach (line_ ${sourcecode})
+  if (line_ MATCHES "^[ \\t]+throw[ ]+soci_error[ ]*\\([ ]*\"Value outside of allowed.+$")
+    set (line_ "//${CMAKE_MATCH_0}")
+  endif ()
+  file (APPEND include/soci/unsigned-types.h.patched "${line_}\n")
+endforeach ()
+execute_process( COMMAND ${CMAKE_COMMAND} -E compare_files
+                 include/soci/unsigned-types.h include/soci/unsigned-types.h.patched
+                 RESULT_VARIABLE compare_result
+)
+if( compare_result EQUAL 0)
+  message(DEBUG "The soci source and patch files are identical. Make no changes.")
+  file (REMOVE include/soci/unsigned-types.h.patched)
+  return()
+endif()
+file (RENAME include/soci/unsigned-types.h include/soci/unsigned-types.h.orig)
+file (RENAME include/soci/unsigned-types.h.patched include/soci/unsigned-types.h)
+# also fix Boost.cmake so that it just returns when we override the Boost_FOUND var
+file (APPEND cmake/dependencies/Boost.cmake.patched "if (Boost_FOUND)\n")
+file (APPEND cmake/dependencies/Boost.cmake.patched "  return ()\n")
+file (APPEND cmake/dependencies/Boost.cmake.patched "endif ()\n")
+file (STRINGS cmake/dependencies/Boost.cmake sourcecode)
+foreach (line_ ${sourcecode})
+  file (APPEND cmake/dependencies/Boost.cmake.patched "${line_}\n")
+endforeach ()
+file (RENAME cmake/dependencies/Boost.cmake.patched cmake/dependencies/Boost.cmake)
+

Builds/CMake/target_protobuf_sources.cmake

@@ -0,0 +1,62 @@
+find_package(Protobuf REQUIRED)
+
+# .proto files import each other like this:
+#
+# import "path/to/file.proto";
+#
+# For the protobuf compiler to find these imports,
+# the parent directory of "path" must be in the import path.
+#
+# When generating C++,
+# it turns into an include statement like this:
+#
+# #include "path/to/file.pb.h"
+#
+# and the header is generated at a path relative to the output directory
+# that matches the given .proto path relative to the source directory
+# minus the first matching prefix on the import path.
+#
+# In other words, a file `include/package/path/to/file.proto`
+# with import path [`include/package`, `include`]
+# will generate files `output/path/to/file.pb.{h,cc}`
+# with includes like `#include "path/to/file.pb.h".
+#
+# During build, the generated files can find each other if the output
+# directory is an include directory, but we want to install that directory
+# under our package's include directory (`include/package`), not as a sibling.
+# After install, they can find each other if that subdirectory is an include
+# directory.
+
+# Add protocol buffer sources to an existing library target.
+# target:
+#     The name of the library target.
+# prefix:
+#     The install prefix for headers relative to `CMAKE_INSTALL_INCLUDEDIR`.
+#     This prefix should appear at the start of all your consumer includes.
+# ARGN:
+#     A list of .proto files.
+function(target_protobuf_sources target prefix)
+  set(dir "${CMAKE_CURRENT_BINARY_DIR}/pb-${target}")
+  file(MAKE_DIRECTORY "${dir}/${prefix}")
+
+  protobuf_generate(
+    TARGET ${target}
+    PROTOC_OUT_DIR "${dir}/${prefix}"
+    "${ARGN}"
+  )
+  target_include_directories(${target} SYSTEM PUBLIC
+    # Allows #include <package/path/to/file.proto> used by consumer files.
+    $<BUILD_INTERFACE:${dir}>
+    # Allows #include "path/to/file.proto" used by generated files.
+    $<BUILD_INTERFACE:${dir}/${prefix}>
+    # Allows #include <package/path/to/file.proto> used by consumer files.
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    # Allows #include "path/to/file.proto" used by generated files.
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>
+  )
+  install(
+    DIRECTORY ${dir}/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    FILES_MATCHING PATTERN "*.h"
+  )
+endfunction()

Builds/README.md

@@ -1 +0,0 @@
-[Please see the BUILD instructions here](../BUILD.md)

Builds/levelization/results/loops.txt

@@ -53,7 +53,7 @@ Loop: test.app test.jtx
   test.app > test.jtx
 
 Loop: test.app test.rpc
-  test.rpc == test.app
+  test.rpc ~= test.app
 
 Loop: test.jtx test.toplevel
   test.toplevel > test.jtx

Builds/levelization/results/ordering.txt

@@ -140,6 +140,8 @@ test.jtx > ripple.json
 test.jtx > ripple.ledger
 test.jtx > ripple.net
 test.jtx > ripple.protocol
+test.jtx > ripple.resource
+test.jtx > ripple.rpc
 test.jtx > ripple.server
 test.ledger > ripple.app
 test.ledger > ripple.basics
@@ -166,7 +168,6 @@ test.nodestore > test.unit_test
 test.overlay > ripple.app
 test.overlay > ripple.basics
 test.overlay > ripple.beast
-test.overlay > ripple.core
 test.overlay > ripple.overlay
 test.overlay > ripple.peerfinder
 test.overlay > ripple.protocol

CMakeLists.txt

@@ -1,4 +1,7 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required (VERSION 3.16)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(POLICY CMP0074)
   cmake_policy(SET CMP0074 NEW)
@@ -11,17 +14,17 @@ endif()
 file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake")
 
-project(rippled)
-set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(POLICY CMP0144)
+  cmake_policy(SET CMP0144 NEW)
+endif()
 
+project (rippled)
 set(Boost_NO_BOOST_CMAKE ON)
 
 # make GIT_COMMIT_HASH define available to all sources
 find_package(Git)
 if(Git_FOUND)
-    execute_process(COMMAND ${GIT_EXECUTABLE} describe --always --abbrev=40
+    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git describe --always --abbrev=40
         OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
     if(gch)
         set(GIT_COMMIT_HASH "${gch}")
@@ -36,11 +39,26 @@ if(thread_safety_analysis)
   add_link_options("-stdlib=libc++")
 endif()
 
+option(USE_CONAN "Use Conan package manager for dependencies" OFF)
+# Then, auto-detect if conan_toolchain.cmake is being used
+if(CMAKE_TOOLCHAIN_FILE)
+  # Check if the toolchain file path contains "conan_toolchain"
+  if(CMAKE_TOOLCHAIN_FILE MATCHES "conan_toolchain")
+    set(USE_CONAN ON CACHE BOOL "Using Conan detected from toolchain file" FORCE)
+    message(STATUS "Conan toolchain detected: ${CMAKE_TOOLCHAIN_FILE}")
+    message(STATUS "Building with Conan dependencies")
+  endif()
+endif()
+
+if (NOT USE_CONAN)
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake")
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/deps")
+endif()
+
 include (CheckCXXCompilerFlag)
 include (FetchContent)
 include (ExternalProject)
 include (CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
-include (ProcessorCount)
 if (target)
   message (FATAL_ERROR "The target option has been removed - use native cmake options to control build")
 endif ()
@@ -48,6 +66,9 @@ endif ()
 include(RippledSanity)
 include(RippledVersion)
 include(RippledSettings)
+if (NOT USE_CONAN)
+  include(RippledNIH)
+endif()
 # this check has to remain in the top-level cmake
 # because of the early return statement
 if (packages_only)
@@ -60,74 +81,101 @@ include(RippledCompiler)
 include(RippledInterface)
 
 ###
-
-include(deps/Boost)
-find_package(OpenSSL 1.1.1 REQUIRED)
-set_target_properties(OpenSSL::SSL PROPERTIES
-  INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
-)
-add_subdirectory(src/secp256k1)
-add_subdirectory(src/ed25519-donna)
-find_package(lz4 REQUIRED)
-# Target names with :: are not allowed in a generator expression.
-# We need to pull the include directories and imported location properties
-# from separate targets.
-find_package(LibArchive REQUIRED)
-find_package(SOCI REQUIRED)
-find_package(SQLite3 REQUIRED)
-find_package(Snappy REQUIRED)
-find_package(wasmedge REQUIRED)
-
-option(rocksdb "Enable RocksDB" ON)
-if(rocksdb)
-  find_package(RocksDB REQUIRED)
-  set_target_properties(RocksDB::rocksdb PROPERTIES
-    INTERFACE_COMPILE_DEFINITIONS RIPPLE_ROCKSDB_AVAILABLE=1
-  )
-  target_link_libraries(ripple_libs INTERFACE RocksDB::rocksdb)
-endif()
-
-find_package(nudb REQUIRED)
-find_package(date REQUIRED)
-include(deps/Protobuf)
-include(deps/gRPC)
-
-target_link_libraries(ripple_libs INTERFACE
-  ed25519::ed25519
-  LibArchive::LibArchive
-  lz4::lz4
-  OpenSSL::Crypto
-  OpenSSL::SSL
-  Ripple::grpc_pbufs
-  Ripple::pbufs
-  secp256k1::secp256k1
-  soci::soci
-  SQLite::SQLite3
-)
-
-if(TARGET nudb::core)
-  set(nudb nudb::core)
-elseif(TARGET NuDB::nudb)
-  set(nudb NuDB::nudb)
+if (NOT USE_CONAN)
+  set(SECP256K1_INSTALL TRUE)
+  add_subdirectory(external/secp256k1)
+  add_library(secp256k1::secp256k1 ALIAS secp256k1)
+  add_subdirectory(external/ed25519-donna)
+  include(deps/Boost)
+  include(deps/OpenSSL)
+  # include(deps/Secp256k1)
+  # include(deps/Ed25519-donna)
+  include(deps/Lz4)
+  include(deps/Libarchive)
+  include(deps/Sqlite)
+  include(deps/Soci)
+  include(deps/Snappy)
+  include(deps/Rocksdb)
+  include(deps/Nudb)
+  include(deps/date)
+  # include(deps/Protobuf)
+  # include(deps/gRPC)
+  include(deps/cassandra)
+  include(deps/Postgres)
+  include(deps/WasmEdge)
 else()
-  message(FATAL_ERROR "unknown nudb target")
-endif()
-target_link_libraries(ripple_libs INTERFACE ${nudb})
-
-if(reporting)
-  find_package(cassandra-cpp-driver REQUIRED)
-  find_package(PostgreSQL REQUIRED)
-  target_link_libraries(ripple_libs INTERFACE
-    cassandra-cpp-driver::cassandra-cpp-driver
-    PostgreSQL::PostgreSQL
+  include(conan/Boost)
+  find_package(OpenSSL 1.1.1 REQUIRED)
+  set_target_properties(OpenSSL::SSL PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
   )
+  set(SECP256K1_INSTALL TRUE)
+  add_subdirectory(external/secp256k1)
+  add_library(secp256k1::secp256k1 ALIAS secp256k1)
+  add_subdirectory(external/ed25519-donna)
+  find_package(gRPC REQUIRED)
+  find_package(lz4 REQUIRED)
+  # Target names with :: are not allowed in a generator expression.
+  # We need to pull the include directories and imported location properties
+  # from separate targets.
+  find_package(LibArchive REQUIRED)
+  find_package(SOCI REQUIRED)
+  find_package(SQLite3 REQUIRED)
+  find_package(Snappy REQUIRED)
+  find_package(wasmedge REQUIRED)
+  option(rocksdb "Enable RocksDB" ON)
+  if(rocksdb)
+    find_package(RocksDB REQUIRED)
+    set_target_properties(RocksDB::rocksdb PROPERTIES
+      INTERFACE_COMPILE_DEFINITIONS RIPPLE_ROCKSDB_AVAILABLE=1
+    )
+    target_link_libraries(ripple_libs INTERFACE RocksDB::rocksdb)
+  endif()
+  find_package(nudb REQUIRED)
+  find_package(date REQUIRED)
+  find_package(xxHash REQUIRED)
+    if(TARGET nudb::core)
+    set(nudb nudb::core)
+  elseif(TARGET NuDB::nudb)
+    set(nudb NuDB::nudb)
+  else()
+    message(FATAL_ERROR "unknown nudb target")
+  endif()
+  target_link_libraries(ripple_libs INTERFACE ${nudb})
+
+  if(reporting)
+    find_package(cassandra-cpp-driver REQUIRED)
+    find_package(PostgreSQL REQUIRED)
+    target_link_libraries(ripple_libs INTERFACE
+      cassandra-cpp-driver::cassandra-cpp-driver
+      PostgreSQL::PostgreSQL
+    )
+  endif()
+  target_link_libraries(ripple_libs INTERFACE
+    ed25519::ed25519
+    lz4::lz4
+    OpenSSL::Crypto
+    OpenSSL::SSL
+    # Ripple::grpc_pbufs
+    # Ripple::pbufs
+    secp256k1::secp256k1
+    soci::soci
+    SQLite::SQLite3
+  )
+endif()
+
+if(coverage)
+  include(RippledCov)
 endif()
 
 ###
 
 include(RippledCore)
+if (NOT USE_CONAN)
+  include(deps/Protobuf)
+  include(deps/gRPC)
+endif()
 include(RippledInstall)
-include(RippledCov)
 include(RippledMultiConfig)
 include(RippledDocs)
 include(RippledValidatorKeys)

CONTRIBUTING.md

@@ -123,6 +123,25 @@ pip3 install pre-commit
 pre-commit install
 ```
 
+## Unit Tests
+To execute all unit tests:
+
+```rippled --unittest --unittest-jobs=<number of cores>```
+
+(Note: Using multiple cores on a Mac M1 can cause spurious test failures. The 
+cause is still under investigation. If you observe this problem, try specifying fewer jobs.)
+
+To run a specific set of test suites:
+
+```
+rippled --unittest TestSuiteName
+```
+Note: In this example, all tests with prefix `TestSuiteName` will be run, so if
+`TestSuiteName1` and `TestSuiteName2` both exist, then both tests will run. 
+Alternatively, if the unit test name finds an exact match, it will stop 
+doing partial matches, i.e. if a unit test with a title of `TestSuiteName` 
+exists, then no other unit test will be executed, apart from `TestSuiteName`.
+
 ## Avoid
 
 1. Proliferation of nearly identical code.
@@ -182,4 +201,4 @@ existing maintainer without a vote.
 
 
 [1]: https://docs.github.com/en/get-started/quickstart/contributing-to-projects
-[2]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/about-pull-request-merges#squash-and-merge-your-commits
+[2]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/about-pull-request-merges#squash-and-merge-your-commits

README.md

@@ -1,4 +1,4 @@
-# Xahau
+# Xahau 
 
 **Note:** Throughout this README, references to "we" or "our" pertain to the community and contributors involved in the Xahau network. It does not imply a legal entity or a specific collection of individuals.
 
@@ -67,5 +67,5 @@ git-subtree. See those directories' README files for more details.
   - [explorer.xahau.network](https://explorer.xahau.network)
 - **Testnet & Faucet**: Test applications and obtain test XAH at [xahau-test.net](https://xahau-test.net) and use the testnet explorer at [explorer.xahau.network](https://explorer.xahau.network).
 - **Supporting Wallets**: A list of wallets that support XAH and Xahau-based assets.
-  - [Xumm](https://xumm.app)
-  - [Crossmark](https://crossmark.io)
+  - [Xaman](https://xaman.app)
+  - [Crossmark](https://crossmark.io)

RELEASENOTES.md

@@ -7,6 +7,253 @@ This document contains the release notes for `rippled`, the reference server imp
  
 Have new ideas? Need help with setting up your node? [Please open an issue here](https://github.com/xrplf/rippled/issues/new/choose).
 
+# Introducing XRP Ledger version 1.12.0
+
+Version 1.12.0 of `rippled`, the reference server implementation of the XRP Ledger protocol, is now available. This release adds new features and bug fixes, and introduces these amendments:
+
+- `AMM`
+- `Clawback`
+- `fixReducedOffersV1`
+
+[Sign Up for Future Release Announcements](https://groups.google.com/g/ripple-server)
+
+<!-- BREAK -->
+
+## Action Required
+
+Three new amendments are now open for voting according to the XRP Ledger's [amendment process](https://xrpl.org/amendments.html), which enables protocol changes following two weeks of >80% support from trusted validators.
+
+If you operate an XRP Ledger server, upgrade to version 1.12.0 by September 20, 2023 to ensure service continuity. The exact time that protocol changes take effect depends on the voting decisions of the decentralized network.
+
+
+## Install / Upgrade
+
+On supported platforms, see the [instructions on installing or updating `rippled`](https://xrpl.org/install-rippled.html).
+
+The XRPL Foundation publishes portable binaries, which are drop-in replacements for the `rippled` daemon. [See information and downloads for the portable binaries](https://github.com/XRPLF/rippled-portable-builds#portable-builds-of-the-rippled-server). This will work on most distributions, including Ubuntu 16.04, 18.04, 20.04, and 22.04; CentOS; and others. Please test and open issues on GitHub if there are problems.
+
+
+## Changelog
+
+### Amendments, New Features, and Changes
+(These are changes which may impact or be useful to end users. For example, you may be able to update your code/workflow to take advantage of these changes.)
+
+- **`AMM`**: Introduces an automated market maker (AMM) protocol to the XRP Ledger's decentralized exchange, enabling you to trade assets without a counterparty. For more information about AMMs, see: [Automated Market Maker](https://opensource.ripple.com/docs/xls-30d-amm/amm-uc/). [#4294](https://github.com/XRPLF/rippled/pull/4294)
+
+- **`Clawback`**: Adds a setting, *Allow Clawback*, which lets an issuer recover, or _claw back_, tokens that they previously issued. Issuers cannot enable this setting if they have issued tokens already. For additional documentation on this feature, see: [#4553](https://github.com/XRPLF/rippled/pull/4553).
+
+- **`fixReducedOffersV1`**: Reduces the occurrence of order books that are blocked by reduced offers. [#4512](https://github.com/XRPLF/rippled/pull/4512)
+
+- Added WebSocket and RPC port info to `server_info` responses. [#4427](https://github.com/XRPLF/rippled/pull/4427)
+
+- Removed the deprecated `accepted`, `seqNum`, `hash`, and `totalCoins` fields from the `ledger` method. [#4244](https://github.com/XRPLF/rippled/pull/4244)
+
+
+### Bug Fixes and Performance Improvements
+(These are behind-the-scenes improvements, such as internal changes to the code, which are not expected to impact end users.)
+
+- Added a pre-commit hook that runs the clang-format linter locally before committing changes. To install this feature, see: [CONTRIBUTING](https://github.com/XRPLF/xrpl-dev-portal/blob/master/CONTRIBUTING.md). [#4599](https://github.com/XRPLF/rippled/pull/4599)
+
+- In order to make it more straightforward to catch and handle overflows: changed the output type of the `mulDiv()` function from `std::pair<bool, uint64_t>` to `std::optional`. [#4243](https://github.com/XRPLF/rippled/pull/4243)
+
+- Updated `Handler::Condition` enum values to make the code less brittle. [#4239](https://github.com/XRPLF/rippled/pull/4239)
+
+- Renamed `ServerHandlerImp` to `ServerHandler`. [#4516](https://github.com/XRPLF/rippled/pull/4516), [#4592](https://github.com/XRPLF/rippled/pull/4592)
+
+- Replaced hand-rolled code with `std::from_chars` for better maintainability. [#4473](https://github.com/XRPLF/rippled/pull/4473)
+
+- Removed an unused `TypedField` move constructor. [#4567](https://github.com/XRPLF/rippled/pull/4567)
+
+
+### Docs and Build System
+
+- Updated checkout versions to resolve warnings during GitHub jobs. [#4598](https://github.com/XRPLF/rippled/pull/4598)
+
+- Fixed an issue with the Debian package build. [#4591](https://github.com/XRPLF/rippled/pull/4591)
+
+- Updated build instructions with additional steps to take after updating dependencies. [#4623](https://github.com/XRPLF/rippled/pull/4623)
+
+- Updated contributing doc to clarify that beta releases should also be pushed to the `release` branch. [#4589](https://github.com/XRPLF/rippled/pull/4589)
+
+- Enabled the `BETA_RPC_API` flag in the default unit tests config, making the API v2 (beta) available to unit tests. [#4573](https://github.com/XRPLF/rippled/pull/4573)
+
+- Conan dependency management.
+  - Fixed package definitions for Conan. [#4485](https://github.com/XRPLF/rippled/pull/4485)
+  - Updated build dependencies to the most recent versions in Conan Center. [#4595](https://github.com/XRPLF/rippled/pull/4595)
+  - Updated Conan recipe for NuDB. [#4615](https://github.com/XRPLF/rippled/pull/4615)
+
+- Added binary hardening and linker flags to enhance security during the build process. [#4603](https://github.com/XRPLF/rippled/pull/4603)
+
+- Added an Artifactory to the `nix` workflow to improve build times. [#4556](https://github.com/XRPLF/rippled/pull/4556)
+
+- Added quality-of-life improvements to workflows, using new [concurrency control](https://docs.github.com/en/actions/using-jobs/using-concurrency) features. [#4597](https://github.com/XRPLF/rippled/pull/4597)
+
+
+[Full Commit Log](https://github.com/XRPLF/rippled/compare/1.11.0...1.12.0)
+
+
+### GitHub
+
+The public source code repository for `rippled` is hosted on GitHub at <https://github.com/XRPLF/rippled>.
+
+We welcome all contributions and invite everyone to join the community of XRP Ledger developers to help build the Internet of Value.
+
+
+## Credits
+
+The following people contributed directly to this release:
+
+- Alphonse N. Mousse <39067955+a-noni-mousse@users.noreply.github.com>
+- Arihant Kothari <arihantkothari17@gmail.com>
+- Chenna Keshava B S <21219765+ckeshava@users.noreply.github.com>
+- Denis Angell <dangell@transia.co>
+- Ed Hennis <ed@ripple.com>
+- Elliot Lee <github.public@intelliot.com>
+- Gregory Tsipenyuk <gregtatcam@users.noreply.github.com>
+- Howard Hinnant <howard.hinnant@gmail.com>
+- Ikko Eltociear Ashimine <eltociear@gmail.com>
+- John Freeman <jfreeman08@gmail.com>
+- Manoj Doshi <mdoshi@ripple.com>
+- Mark Travis <mtravis@ripple.com>
+- Mayukha Vadari <mvadari@gmail.com>
+- Michael Legleux <legleux@users.noreply.github.com>
+- Peter Chen <34582813+PeterChen13579@users.noreply.github.com>
+- RichardAH <richard.holland@starstone.co.nz>
+- Rome Reginelli <rome@ripple.com>
+- Scott Schurr <scott@ripple.com>
+- Shawn Xie <35279399+shawnxie999@users.noreply.github.com>
+- drlongle <drlongle@gmail.com>
+
+Bug Bounties and Responsible Disclosures:
+
+We welcome reviews of the rippled code and urge researchers to responsibly disclose any issues they may find.
+
+To report a bug, please send a detailed report to: <bugs@xrpl.org>
+
+
+# Introducing XRP Ledger version 1.11.0
+
+Version 1.11.0 of `rippled`, the reference server implementation of the XRP Ledger protocol, is now available.
+
+This release reduces memory usage, introduces the `fixNFTokenRemint` amendment, and adds new features and bug fixes. For example, the new NetworkID field in transactions helps to prevent replay attacks with side-chains.
+
+[Sign Up for Future Release Announcements](https://groups.google.com/g/ripple-server)
+
+<!-- BREAK -->
+
+## Action Required
+
+The `fixNFTokenRemint` amendment is now open for voting according to the XRP Ledger's [amendment process](https://xrpl.org/amendments.html), which enables protocol changes following two weeks of >80% support from trusted validators.
+
+If you operate an XRP Ledger server, upgrade to version 1.11.0 by July 5 to ensure service continuity. The exact time that protocol changes take effect depends on the voting decisions of the decentralized network.
+
+
+## Install / Upgrade
+
+On supported platforms, see the [instructions on installing or updating `rippled`](https://xrpl.org/install-rippled.html).
+
+
+## What's Changed
+
+### New Features and Improvements
+
+* Allow port numbers be be specified using a either a colon or a space by @RichardAH in https://github.com/XRPLF/rippled/pull/4328
+* Eliminate memory allocation from critical path: by @nbougalis in https://github.com/XRPLF/rippled/pull/4353
+* Make it easy for projects to depend on libxrpl by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4449
+* Add the ability to mark amendments as obsolete by @ximinez in https://github.com/XRPLF/rippled/pull/4291
+* Always create the FeeSettings object in genesis ledger by @ximinez in https://github.com/XRPLF/rippled/pull/4319
+* Log exception messages in several locations by @drlongle in https://github.com/XRPLF/rippled/pull/4400
+* Parse flags in account_info method by @drlongle in https://github.com/XRPLF/rippled/pull/4459
+* Add NFTokenPages to account_objects RPC by @RichardAH in https://github.com/XRPLF/rippled/pull/4352
+* add jss fields used by clio `nft_info` by @ledhed2222 in https://github.com/XRPLF/rippled/pull/4320
+* Introduce a slab-based memory allocator and optimize SHAMapItem by @nbougalis in https://github.com/XRPLF/rippled/pull/4218
+* Add NetworkID field to transactions to help prevent replay attacks on and from side-chains by @RichardAH in https://github.com/XRPLF/rippled/pull/4370
+* If present, set quorum based on command line. by @mtrippled in https://github.com/XRPLF/rippled/pull/4489
+* API does not accept seed or public key for account by @drlongle in https://github.com/XRPLF/rippled/pull/4404
+* Add `nftoken_id`, `nftoken_ids` and `offer_id` meta fields into NFT `Tx` responses by @shawnxie999 in https://github.com/XRPLF/rippled/pull/4447
+
+### Bug Fixes
+
+* fix(gateway_balances): handle overflow exception by @RichardAH in https://github.com/XRPLF/rippled/pull/4355
+* fix(ValidatorSite): handle rare null pointer dereference in timeout by @ximinez in https://github.com/XRPLF/rippled/pull/4420
+* RPC commands understand markers derived from all ledger object types by @ximinez in https://github.com/XRPLF/rippled/pull/4361
+* `fixNFTokenRemint`: prevent NFT re-mint: by @shawnxie999 in https://github.com/XRPLF/rippled/pull/4406
+* Fix a case where ripple::Expected returned a json array, not a value by @scottschurr in https://github.com/XRPLF/rippled/pull/4401
+* fix: Ledger data returns an empty list (instead of null) when all entries are filtered out by @drlongle in https://github.com/XRPLF/rippled/pull/4398
+* Fix unit test ripple.app.LedgerData by @drlongle in https://github.com/XRPLF/rippled/pull/4484
+* Fix the fix for std::result_of by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4496
+* Fix errors for Clang 16 by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4501
+* Ensure that switchover vars are initialized before use: by @seelabs in https://github.com/XRPLF/rippled/pull/4527
+* Move faulty assert by @ximinez in https://github.com/XRPLF/rippled/pull/4533
+* Fix unaligned load and stores: (#4528) by @seelabs in https://github.com/XRPLF/rippled/pull/4531
+* fix node size estimation by @dangell7 in https://github.com/XRPLF/rippled/pull/4536
+* fix: remove redundant moves by @ckeshava in https://github.com/XRPLF/rippled/pull/4565
+
+### Code Cleanup and Testing
+
+* Replace compare() with the three-way comparison operator in base_uint, Issue and Book by @drlongle in https://github.com/XRPLF/rippled/pull/4411
+* Rectify the import paths of boost::function_output_iterator by @ckeshava in https://github.com/XRPLF/rippled/pull/4293
+* Expand Linux test matrix by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4454
+* Add patched recipe for SOCI by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4510
+* Switch to self-hosted runners for macOS by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4511
+* [TRIVIAL] Add missing includes by @seelabs in https://github.com/XRPLF/rippled/pull/4555
+
+### Docs
+
+* Refactor build instructions by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4381
+* Add install instructions for package managers by @thejohnfreeman in https://github.com/XRPLF/rippled/pull/4472
+* Fix typo by @solmsted in https://github.com/XRPLF/rippled/pull/4508
+* Update environment.md by @sappenin in https://github.com/XRPLF/rippled/pull/4498
+* Update BUILD.md by @oeggert in https://github.com/XRPLF/rippled/pull/4514
+* Trivial: add comments for NFToken-related invariants by @scottschurr in https://github.com/XRPLF/rippled/pull/4558
+
+## New Contributors
+* @drlongle made their first contribution in https://github.com/XRPLF/rippled/pull/4411
+* @ckeshava made their first contribution in https://github.com/XRPLF/rippled/pull/4293
+* @solmsted made their first contribution in https://github.com/XRPLF/rippled/pull/4508
+* @sappenin made their first contribution in https://github.com/XRPLF/rippled/pull/4498
+* @oeggert made their first contribution in https://github.com/XRPLF/rippled/pull/4514
+
+**Full Changelog**: https://github.com/XRPLF/rippled/compare/1.10.1...1.11.0
+
+
+### GitHub
+
+The public source code repository for `rippled` is hosted on GitHub at <https://github.com/XRPLF/rippled>.
+
+We welcome all contributions and invite everyone to join the community of XRP Ledger developers to help build the Internet of Value.
+
+### Credits
+
+The following people contributed directly to this release:
+- Alloy Networks <45832257+alloynetworks@users.noreply.github.com>
+- Brandon Wilson <brandon@coil.com>
+- Chenna Keshava B S <21219765+ckeshava@users.noreply.github.com>
+- David Fuelling <sappenin@gmail.com>
+- Denis Angell <dangell@transia.co>
+- Ed Hennis <ed@ripple.com>
+- Elliot Lee <github.public@intelliot.com>
+- John Freeman <jfreeman08@gmail.com>
+- Mark Travis <mtrippled@users.noreply.github.com>
+- Nik Bougalis <nikb@bougalis.net>
+- RichardAH <richard.holland@starstone.co.nz>
+- Scott Determan <scott.determan@yahoo.com>
+- Scott Schurr <scott@ripple.com>
+- Shawn Xie <35279399+shawnxie999@users.noreply.github.com>
+- drlongle <drlongle@gmail.com>
+- ledhed2222 <ledhed2222@users.noreply.github.com>
+- oeggert <117319296+oeggert@users.noreply.github.com>
+- solmsted <steven.olm@gmail.com>
+
+
+Bug Bounties and Responsible Disclosures:
+We welcome reviews of the rippled code and urge researchers to
+responsibly disclose any issues they may find.
+
+To report a bug, please send a detailed report to:
+
+    bugs@xrpl.org
+
 
 # Introducing XRP Ledger version 1.10.1
 

SECURITY.md

@@ -61,13 +61,12 @@ For these complaints or reports, please [contact our support team](mailto:bugs@x
 
 ### The following type of security problems are excluded
 
-- (D)DOS attacks
-- Error messages or error pages without sensitive data
-- Tests & sample data as publicly available in our repositories at Github
-- Common issues like browser header warnings or DNS configuration, identified by vulnerability scans
-- Vulnerability scan reports for software we publicly use
-- Security issues related to outdated OS's, browsers or plugins
-- Reports for security problems that we have been notified of before
+1. **In scope**. Only bugs in software under the scope of the program qualify. Currently, that means `xahaud` and `xahau-lib`.
+2. **Relevant**. A security issue, posing a danger to user funds, privacy or the operation of the Xahau Ledger.
+3. **Original and previously unknown**. Bugs that are already known and discussed in public do not qualify. Previously reported bugs, even if publicly unknown, are not eligible.
+4. **Specific**. We welcome general security advice or recommendations, but we cannot pay bounties for that.
+5. **Fixable**. There has to be something we can do to permanently fix the problem. Note that bugs in other people’s software may still qualify in some cases. For example, if you find a bug in a library that we use which can compromise the security of software that is in scope and we can get it fixed, you may qualify for a bounty.
+6. **Unused**. If you use the exploit to attack the Xahau Ledger, you do not qualify for a bounty. If you report a vulnerability used in an ongoing or past attack and there is specific, concrete evidence that suggests you are the attacker we reserve the right not to pay a bounty.
 
 Please note: Reports that are lacking any proof (such as screenshots or other data), detailed information or details on how to reproduce any unexpected result will be investigated but will not be eligible for any reward.
 

build-core.sh

@@ -1,4 +1,11 @@
-#!/bin/bash
+#!/bin/bash -u
+# We use set -e and bash with -u to bail on first non zero exit code of any
+# processes launched or upon any unbound variable.
+# We use set -x to print commands before running them to help with
+# debugging.
+set -ex
+
+set -e
 
 echo "START INSIDE CONTAINER - CORE"
 
@@ -23,12 +30,12 @@ fi
 perl -i -pe "s/^(\\s*)-DBUILD_SHARED_LIBS=OFF/\\1-DBUILD_SHARED_LIBS=OFF\\n\\1-DROCKSDB_BUILD_SHARED=OFF/g" Builds/CMake/deps/Rocksdb.cmake &&
 mv Builds/CMake/deps/WasmEdge.cmake Builds/CMake/deps/WasmEdge.old &&
 echo "find_package(LLVM REQUIRED CONFIG)
-message(STATUS \"Found LLVM ${LLVM_PACKAGE_VERSION}\")
+message(STATUS \"Found LLVM \${LLVM_PACKAGE_VERSION}\")
 message(STATUS \"Using LLVMConfig.cmake in: \${LLVM_DIR}\")
 add_library (wasmedge STATIC IMPORTED GLOBAL)
 set_target_properties(wasmedge PROPERTIES IMPORTED_LOCATION \${WasmEdge_LIB})
 target_link_libraries (ripple_libs INTERFACE wasmedge)
-add_library (NIH::WasmEdge ALIAS wasmedge)
+add_library (wasmedge::wasmedge ALIAS wasmedge)
 message(\"WasmEdge DONE\")
 " > Builds/CMake/deps/WasmEdge.cmake &&
 git checkout src/ripple/protocol/impl/BuildInfo.cpp &&

build-full.sh

@@ -1,4 +1,11 @@
-#!/bin/bash
+#!/bin/bash -u
+# We use set -e and bash with -u to bail on first non zero exit code of any
+# processes launched or upon any unbound variable.
+# We use set -x to print commands before running them to help with
+# debugging.
+set -ex
+
+set -e
 
 echo "START INSIDE CONTAINER - FULL"
 
@@ -9,8 +16,17 @@ echo "-- GITHUB_RUN_NUMBER: $4"
 
 umask 0000;
 
+echo "Fixing CentOS 7 EOL"
+
+sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
+sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
+yum clean all
+yum-config-manager --disable centos-sclo-sclo
+
+####
+
 cd /io;
-mkdir src/certs;
+mkdir -p src/certs;
 curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h;
 if [ "`grep certbundle.h src/ripple/net/impl/RegisterSSLCerts.cpp | wc -l`" -eq "0" ]
 then
@@ -57,8 +73,8 @@ then
     #endif/g" src/ripple/net/impl/RegisterSSLCerts.cpp &&
     sed -i "s/#include <ripple\/net\/RegisterSSLCerts.h>/\0\n#include <certs\/certbundle.h>/g" src/ripple/net/impl/RegisterSSLCerts.cpp
 fi
-mkdir .nih_c;
-mkdir .nih_toolchain;
+mkdir -p .nih_c;
+mkdir -p .nih_toolchain;
 cd .nih_toolchain &&
 yum install -y wget lz4 lz4-devel git llvm13-static.x86_64 llvm13-devel.x86_64 devtoolset-10-binutils zlib-static ncurses-static -y \
   devtoolset-7-gcc-c++ \
@@ -81,11 +97,11 @@ echo "-- Install Cmake 3.23.1 --" &&
 pwd &&
 ( wget -nc -q https://github.com/Kitware/CMake/releases/download/v3.23.1/cmake-3.23.1-linux-x86_64.tar.gz; echo "" ) &&
 tar -xzf cmake-3.23.1-linux-x86_64.tar.gz -C /hbb/ &&
-echo "-- Install Boost 1.75.0 --" &&
+echo "-- Install Boost 1.86.0 --" &&
 pwd &&
-( wget -nc -q https://boostorg.jfrog.io/artifactory/main/release/1.75.0/source/boost_1_75_0.tar.gz; echo "" ) &&
-tar -xzf boost_1_75_0.tar.gz &&
-cd boost_1_75_0 && ./bootstrap.sh && ./b2  link=static -j$3 && ./b2 install &&
+( wget -nc -q https://archives.boost.io/release/1.86.0/source/boost_1_86_0.tar.gz; echo "" ) &&
+tar -xzf boost_1_86_0.tar.gz &&
+cd boost_1_86_0 && ./bootstrap.sh && ./b2  link=static -j$3 && ./b2 install &&
 cd ../ &&
 echo "-- Install Protobuf 3.20.0 --" &&
 pwd &&
@@ -106,7 +122,7 @@ tar -xf libunwind-13.0.1.src.tar.xz &&
 cp -r libunwind-13.0.1.src/include libunwind-13.0.1.src/src lld-13.0.1.src/ &&
 cd lld-13.0.1.src &&
 rm -rf build CMakeCache.txt &&
-mkdir build &&
+mkdir -p build &&
 cd build &&
 cmake .. -DLLVM_LIBRARY_DIR=/usr/lib64/llvm13/lib/ -DCMAKE_INSTALL_PREFIX=/usr/lib64/llvm13/ -DCMAKE_BUILD_TYPE=Release &&
 make -j$3 install &&
@@ -116,11 +132,11 @@ cd ../../ &&
 echo "-- Build WasmEdge --" &&
 ( wget -nc -q https://github.com/WasmEdge/WasmEdge/archive/refs/tags/0.11.2.zip; unzip -o 0.11.2.zip; ) &&
 cd WasmEdge-0.11.2 &&
-( mkdir build; echo "" ) &&
+( mkdir -p build; echo "" ) &&
 cd build &&
-export BOOST_ROOT="/usr/local/src/boost_1_75_0" &&
+export BOOST_ROOT="/usr/local/src/boost_1_86_0" &&
 export Boost_LIBRARY_DIRS="/usr/local/lib" &&
-export BOOST_INCLUDEDIR="/usr/local/src/boost_1_75_0" &&
+export BOOST_INCLUDEDIR="/usr/local/src/boost_1_86_0" &&
 export PATH=`echo $PATH | sed -E "s/devtoolset-7/devtoolset-9/g"` &&
 cmake .. \
     -DCMAKE_BUILD_TYPE=Release \

cfg/rippled-example.cfg

@@ -283,12 +283,14 @@
 #       ssl_cert
 #
 #           Specifies the path to the SSL certificate file in PEM format.
-#           This is not needed if the chain includes it.
+#           This is not needed if the chain includes it. Use ssl_chain if
+#           your certificate includes one or more intermediates.
 #
 #       ssl_chain
 #
 #           If you need a certificate chain, specify the path to the
 #           certificate chain here. The chain may include the end certificate.
+#           This must be used if the certificate includes intermediates.
 #
 #   ssl_ciphers = <cipherlist>
 #
@@ -387,6 +389,21 @@
 #
 #
 #
+# [compression]
+#
+#   true or false
+#
+#   true - enables compression
+#   false - disables compression [default].
+#
+#   The rippled server can save bandwidth by compressing its peer-to-peer communications, 
+#   at a cost of greater CPU usage. If you enable link compression, 
+#   the server automatically compresses communications with peer servers
+#   that also have link compression enabled.
+#   https://xrpl.org/enable-link-compression.html
+#
+#
+#
 # [ips]
 #
 #   List of hostnames or ips where the Ripple protocol is served.  A default
@@ -461,19 +478,6 @@
 #
 #
 #
-# [sntp_servers]
-#
-#   IP address or domain of NTP servers to use for time synchronization.
-#
-#   These NTP servers are suitable for rippled servers located in the United
-#   States:
-#      time.windows.com
-#      time.apple.com
-#      time.nist.gov
-#      pool.ntp.org
-#
-#
-#
 # [max_transactions]
 #
 #   Configure the maximum number of transactions to have in the job queue
@@ -1056,7 +1060,18 @@
 #       Cassandra is an alternative backend to be used only with Reporting Mode.
 #       See the Reporting Mode section for more details about Reporting Mode.
 #
-#   Required keys for NuDB and RocksDB:
+#   type = RWDB
+#
+#       RWDB is a high-performance memory store written by XRPL-Labs and optimized
+#       for xahaud. RWDB is NOT persistent and the data will be lost on restart.
+#       RWDB is recommended for Validator and Peer nodes that are not required to 
+#       store history.
+#
+#       RWDB maintains its high speed regardless of the amount of history
+#       stored. Online delete should NOT be used instead RWDB will use the 
+#       ledger_history config value to determine how many ledgers to keep in memory.
+#
+#   Required keys for NuDB, RWDB and RocksDB:
 #
 #       path                Location to store the database
 #
@@ -1112,7 +1127,8 @@
 #       online_delete       Minimum value of 256. Enable automatic purging
 #                           of older ledger information. Maintain at least this
 #                           number of ledger records online. Must be greater
-#                           than or equal to ledger_history.
+#                           than or equal to ledger_history. If using RWDB 
+#                           this value is ignored.
 #
 #       These keys modify the behavior of online_delete, and thus are only
 #       relevant if online_delete is defined and non-zero:
@@ -1637,6 +1653,7 @@ port = 6006
 ip = 127.0.0.1
 admin = 127.0.0.1
 protocol = ws
+send_queue_limit = 500
 
 [port_grpc]
 port = 50051
@@ -1647,6 +1664,7 @@ secure_gateway = 127.0.0.1
 #port = 6005
 #ip = 127.0.0.1
 #protocol = wss
+#send_queue_limit = 500
 
 #-------------------------------------------------------------------------------
 
@@ -1702,12 +1720,6 @@ advisory_delete=0
 [debug_logfile]
 /var/log/rippled/debug.log
 
-[sntp_servers]
-time.windows.com
-time.apple.com
-time.nist.gov
-pool.ntp.org
-
 # To use the XRP test network
 # (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
 # use the following [ips] section:

cfg/rippled-reporting.cfg

@@ -450,19 +450,6 @@
 #
 #
 #
-# [sntp_servers]
-#
-#   IP address or domain of NTP servers to use for time synchronization.
-#
-#   These NTP servers are suitable for rippled servers located in the United
-#   States:
-#      time.windows.com
-#      time.apple.com
-#      time.nist.gov
-#      pool.ntp.org
-#
-#
-#
 # [max_transactions]
 #
 #   Configure the maximum number of transactions to have in the job queue
@@ -1662,12 +1649,6 @@ advisory_delete=0
 [debug_logfile]
 /var/log/rippled-reporting/debug.log
 
-[sntp_servers]
-time.windows.com
-time.apple.com
-time.nist.gov
-pool.ntp.org
-
 # To use the XRP test network
 # (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
 # use the following [ips] section:

cfg/rippled-standalone.cfg

@@ -144,4 +144,12 @@ D686F2538F410C9D0D856788E98E3579595DAF7B38D38887F81ECAC934B06040 HooksUpdate1
 86E83A7D2ECE3AD5FA87AB2195AE015C950469ABF0B72EAACED318F74886AE90 CryptoConditionsSuite
 3C43D9A973AA4443EF3FC38E42DD306160FBFFDAB901CD8BAA15D09F2597EB87 NonFungibleTokensV1
 0285B7E5E08E1A8E4C15636F0591D87F73CB6A7B6452A932AD72BBC8E5D1CBE3 fixNFTokenDirV1
-36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6 fixNFTokenNegOffer
+36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6 fixNFTokenNegOffer
+4C499D17719BB365B69010A436B64FD1A82AAB199FC1CEB06962EBD01059FB09 fixXahauV1
+215181D23BF5C173314B5FDB9C872C92DE6CC918483727DE037C0C13E7E6EE9D fixXahauV2
+0D8BF22FF7570D58598D1EF19EBB6E142AD46E59A223FD3816262FBB69345BEA Remit
+7CA0426E7F411D39BB014E57CD9E08F61DE1750F0D41FCD428D9FB80BB7596B0 ZeroB2M
+4B8466415FAB32FFA89D9DCBE166A42340115771DF611A7160F8D7439C87ECD8 fixNSDelete
+EDB4EE4C524E16BDD91D9A529332DED08DCAAA51CC6DC897ACFA1A0ED131C5B6 fix240819
+8063140E9260799D6716756B891CEC3E7006C4E4F277AB84670663A88F94B9C4 fixPageCap
+88693F108C3CD8A967F3F4253A32DEF5E35F9406ACD2A11B88B11D90865763A9 fix240911

conanfile.py

@@ -1,4 +1,4 @@
-from conans import ConanFile
+from conan import ConanFile
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 import re
 
@@ -24,7 +24,7 @@ class Xrpl(ConanFile):
     }
 
     requires = [
-        'boost/1.82.0',
+        'boost/1.86.0',
         'date/3.0.1',
         'libarchive/3.6.0',
         'lz4/1.9.3',
@@ -36,9 +36,14 @@ class Xrpl(ConanFile):
         'soci/4.0.3',
         'sqlite3/3.42.0',
         'zlib/1.2.13',
+        'xxhash/0.8.2',
         'wasmedge/0.11.2',
     ]
 
+    tool_requires = [
+        'protobuf/3.21.9',
+    ]
+
     default_options = {
         'assertions': False,
         'coverage': False,
@@ -86,6 +91,7 @@ class Xrpl(ConanFile):
         'soci:shared': False,
         'soci:with_sqlite3': True,
         'soci:with_boost': True,
+        'xxhash:shared': False,
     }
 
     def set_version(self):
@@ -109,7 +115,9 @@ class Xrpl(ConanFile):
         if self.options.rocksdb:
             self.requires('rocksdb/6.27.3')
 
-    exports_sources = 'CMakeLists.txt', 'Builds/CMake/*', 'src/*', 'cfg/*'
+    exports_sources = (
+        'CMakeLists.txt', 'Builds/*', 'bin/getRippledInfo', 'src/*', 'cfg/*', 'external/*'
+    )
 
     def layout(self):
         cmake_layout(self)
@@ -143,8 +151,20 @@ class Xrpl(ConanFile):
         cmake.install()
 
     def package_info(self):
-        self.cpp_info.libs = [
-            'libxrpl_core.a',
-            'libed25519-donna.a',
-            'libsecp256k1.a',
+        libxrpl = self.cpp_info.components['libxrpl']
+        libxrpl.libs = [
+            'xrpl_core',
+            'xrpl.libpb',
+            'ed25519',
+            'secp256k1',
+        ]
+        # TODO: Fix the protobufs to include each other relative to
+        # `include/`, not `include/ripple/proto/`.
+        libxrpl.includedirs = ['include', 'include/ripple/proto']
+        libxrpl.requires = [
+            'boost::boost',
+            'openssl::crypto',
+            'date::date',
+            'grpc::grpc++',
+            'xxhash::xxhash',
         ]

docker-unit-tests.sh

@@ -1,4 +1,11 @@
-#!/bin/bash
+#!/bin/bash -x
 
-docker run --rm -i -v $(pwd):/io ubuntu sh -c '/io/release-build/xahaud -u'
+BUILD_CORES=$(echo "scale=0 ; `nproc` / 1.337" | bc)
 
+if [[ "$GITHUB_REPOSITORY" == "" ]]; then
+  #Default
+  BUILD_CORES=8
+fi
+
+echo "Mounting $(pwd)/io in ubuntu and running unit tests"
+docker run --rm -i -v $(pwd):/io -e BUILD_CORES=$BUILD_CORES ubuntu sh -c '/io/release-build/xahaud --unittest-jobs $BUILD_CORES -u'

docs/build/environment.md

@@ -0,0 +1,84 @@
+Our [build instructions][BUILD.md] assume you have a C++ development
+environment complete with Git, Python, Conan, CMake, and a C++ compiler.
+This document exists to help readers set one up on any of the Big Three
+platforms: Linux, macOS, or Windows.
+
+[BUILD.md]: ../../BUILD.md
+
+
+## Linux
+
+Package ecosystems vary across Linux distributions,
+so there is no one set of instructions that will work for every Linux user.
+These instructions are written for Ubuntu 22.04.
+They are largely copied from the [script][1] used to configure our Docker
+container for continuous integration.
+That script handles many more responsibilities.
+These instructions are just the bare minimum to build one configuration of
+rippled.
+You can check that codebase for other Linux distributions and versions.
+If you cannot find yours there,
+then we hope that these instructions can at least guide you in the right
+direction.
+
+```
+apt update
+apt install --yes curl git libssl-dev python3.10-dev python3-pip make g++-11
+
+curl --location --remote-name \
+  "https://github.com/Kitware/CMake/releases/download/v3.25.1/cmake-3.25.1.tar.gz"
+tar -xzf cmake-3.25.1.tar.gz
+rm cmake-3.25.1.tar.gz
+cd cmake-3.25.1
+./bootstrap --parallel=$(nproc)
+make --jobs $(nproc)
+make install
+cd ..
+
+pip3 install 'conan<2'
+```
+
+[1]: https://github.com/thejohnfreeman/rippled-docker/blob/master/ubuntu-22.04/install.sh
+
+
+## macOS
+
+Open a Terminal and enter the below command to bring up a dialog to install
+the command line developer tools.
+Once it is finished, this command should return a version greater than the
+minimum required (see [BUILD.md][]).
+
+```
+clang --version
+```
+
+The command line developer tools should include Git too:
+
+```
+git --version
+```
+
+Install [Homebrew][],
+use it to install [pyenv][],
+use it to install Python,
+and use it to install Conan:
+
+[Homebrew]: https://brew.sh/
+[pyenv]: https://github.com/pyenv/pyenv
+
+```
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+brew update
+brew install xz
+brew install pyenv
+pyenv install 3.10-dev
+pyenv global 3.10-dev
+eval "$(pyenv init -)"
+pip install 'conan<2'
+```
+
+Install CMake with Homebrew too:
+
+```
+brew install cmake
+```

docs/build/install.md

@@ -0,0 +1,159 @@
+This document contains instructions for installing rippled.
+The APT package manager is common on Debian-based Linux distributions like
+Ubuntu,
+while the YUM package manager is common on Red Hat-based Linux distributions
+like CentOS.
+Installing from source is an option for all platforms,
+and the only supported option for installing custom builds.
+
+
+## From source
+
+From a source build, you can install rippled and libxrpl using CMake's
+`--install` mode:
+
+```
+cmake --install . --prefix /opt/local
+```
+
+The default [prefix][1] is typically `/usr/local` on Linux and macOS and
+`C:/Program Files/rippled` on Windows.
+
+[1]: https://cmake.org/cmake/help/latest/variable/CMAKE_INSTALL_PREFIX.html
+
+
+## With the APT package manager
+
+1. Update repositories:
+
+        sudo apt update -y
+
+2. Install utilities:
+
+        sudo apt install -y apt-transport-https ca-certificates wget gnupg
+
+3. Add Ripple's package-signing GPG key to your list of trusted keys:
+
+        sudo mkdir /usr/local/share/keyrings/
+        wget -q -O - "https://repos.ripple.com/repos/api/gpg/key/public" | gpg --dearmor > ripple-key.gpg
+        sudo mv ripple-key.gpg /usr/local/share/keyrings
+
+
+4. Check the fingerprint of the newly-added key:
+
+        gpg /usr/local/share/keyrings/ripple-key.gpg
+
+    The output should include an entry for Ripple such as the following:
+
+        gpg: WARNING: no command supplied.  Trying to guess what you mean ...
+        pub   rsa3072 2019-02-14 [SC] [expires: 2026-02-17]
+            C0010EC205B35A3310DC90DE395F97FFCCAFD9A2
+        uid           TechOps Team at Ripple <techops+rippled@ripple.com>
+        sub   rsa3072 2019-02-14 [E] [expires: 2026-02-17]
+
+
+    In particular, make sure that the fingerprint matches. (In the above example, the fingerprint is on the third line, starting with `C001`.)
+
+4. Add the appropriate Ripple repository for your operating system version:
+
+        echo "deb [signed-by=/usr/local/share/keyrings/ripple-key.gpg] https://repos.ripple.com/repos/rippled-deb focal stable" | \
+            sudo tee -a /etc/apt/sources.list.d/ripple.list
+
+    The above example is appropriate for **Ubuntu 20.04 Focal Fossa**. For other operating systems, replace the word `focal` with one of the following:
+
+    - `jammy` for **Ubuntu 22.04 Jammy Jellyfish**
+    - `bionic` for **Ubuntu 18.04 Bionic Beaver**
+    - `bullseye` for **Debian 11 Bullseye**
+    - `buster` for **Debian 10 Buster**
+
+    If you want access to development or pre-release versions of `rippled`, use one of the following instead of `stable`:
+
+    - `unstable` - Pre-release builds ([`release` branch](https://github.com/ripple/rippled/tree/release))
+    - `nightly` - Experimental/development builds ([`develop` branch](https://github.com/ripple/rippled/tree/develop))
+
+    **Warning:** Unstable and nightly builds may be broken at any time. Do not use these builds for production servers.
+
+5. Fetch the Ripple repository.
+
+        sudo apt -y update
+
+6. Install the `rippled` software package:
+
+        sudo apt -y install rippled
+
+7. Check the status of the `rippled` service:
+
+        systemctl status rippled.service
+
+    The `rippled` service should start automatically. If not, you can start it manually:
+
+        sudo systemctl start rippled.service
+
+8. Optional: allow `rippled` to bind to privileged ports.
+
+    This allows you to serve incoming API requests on port 80 or 443. (If you want to do so, you must also update the config file's port settings.)
+
+        sudo setcap 'cap_net_bind_service=+ep' /opt/ripple/bin/rippled
+
+
+## With the YUM package manager
+
+1. Install the Ripple RPM repository:
+
+    Choose the appropriate RPM repository for the stability of releases you want:
+
+    - `stable` for the latest production release (`master` branch)
+    - `unstable` for pre-release builds (`release` branch)
+    - `nightly` for experimental/development builds (`develop` branch)
+
+    *Stable*
+
+        cat << REPOFILE | sudo tee /etc/yum.repos.d/ripple.repo
+        [ripple-stable]
+        name=XRP Ledger Packages
+        enabled=1
+        gpgcheck=0
+        repo_gpgcheck=1
+        baseurl=https://repos.ripple.com/repos/rippled-rpm/stable/
+        gpgkey=https://repos.ripple.com/repos/rippled-rpm/stable/repodata/repomd.xml.key
+        REPOFILE
+
+    *Unstable*
+
+        cat << REPOFILE | sudo tee /etc/yum.repos.d/ripple.repo
+        [ripple-unstable]
+        name=XRP Ledger Packages
+        enabled=1
+        gpgcheck=0
+        repo_gpgcheck=1
+        baseurl=https://repos.ripple.com/repos/rippled-rpm/unstable/
+        gpgkey=https://repos.ripple.com/repos/rippled-rpm/unstable/repodata/repomd.xml.key
+        REPOFILE
+
+    *Nightly*
+
+        cat << REPOFILE | sudo tee /etc/yum.repos.d/ripple.repo
+        [ripple-nightly]
+        name=XRP Ledger Packages
+        enabled=1
+        gpgcheck=0
+        repo_gpgcheck=1
+        baseurl=https://repos.ripple.com/repos/rippled-rpm/nightly/
+        gpgkey=https://repos.ripple.com/repos/rippled-rpm/nightly/repodata/repomd.xml.key
+        REPOFILE
+
+2. Fetch the latest repo updates:
+
+        sudo yum -y update
+
+3. Install the new `rippled` package:
+
+        sudo yum install -y rippled
+
+4. Configure the `rippled` service to start on boot:
+
+        sudo systemctl enable rippled.service
+
+5. Start the `rippled` service:
+
+        sudo systemctl start rippled.service

external/README.md

@@ -0,0 +1,11 @@
+The subdirectories in this directory contain either copies or Conan recipes
+of external libraries used by rippled.
+The Conan recipes include patches we have not yet pushed upstream.
+
+| Folder          | Upstream                                     | Description |
+|:----------------|:---------------------------------------------|:------------|
+| `ed25519-donna` | [Project](https://github.com/floodyberry/ed25519-donna) | [Ed25519](http://ed25519.cr.yp.to/) digital signatures |
+| `rocksdb`       | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/rocksdb) | Fast key/value database. (Supports rotational disks better than NuDB.) |
+| `secp256k1`     | [Project](https://github.com/bitcoin-core/secp256k1)    | ECDSA digital signatures using the **secp256k1** curve |
+| `snappy`        | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/snappy)  | "Snappy" lossless compression algorithm. |
+| `soci`          | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/soci)    | Abstraction layer for database access. |