fix comment

Co-authored-by: tequ <git@tequ.dev>

.git-blame-ignore-revs

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

.githooks/pre-commit

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Pre-commit hook that runs the suspicious patterns check on staged files
+
+# Get the repository's root directory
+repo_root=$(git rev-parse --show-toplevel)
+
+# Run the suspicious patterns script in pre-commit mode
+"$repo_root/suspicious_patterns.sh" --pre-commit
+
+# Exit with the same code as the script
+exit $?

.githooks/setup.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+echo "Configuring git to use .githooks directory..."
+git config core.hooksPath .githooks

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

@@ -14,6 +14,18 @@ inputs:
     description: 'How to check compiler for changes'
     required: false
     default: 'content'
+  is_main_branch:
+    description: 'Whether the current branch is the main branch'
+    required: false
+    default: 'false'
+  main_cache_dir:
+    description: 'Path to the main branch cache directory'
+    required: false
+    default: '~/.ccache-main'
+  current_cache_dir:
+    description: 'Path to the current branch cache directory'
+    required: false
+    default: '~/.ccache-current'
 
 runs:
   using: 'composite'
@@ -21,11 +33,31 @@ runs:
     - name: Configure ccache
       shell: bash
       run: |
+        # Create cache directories
+        mkdir -p ${{ inputs.main_cache_dir }} ${{ inputs.current_cache_dir }}
+        
+        # Set compiler check globally
+        ccache -o compiler_check=${{ inputs.compiler_check }}
+        
+        # Use a single config file location
         mkdir -p ~/.ccache
-        export CONF_PATH="${CCACHE_CONFIGPATH:-${CCACHE_DIR:-$HOME/.ccache}/ccache.conf}"
-        mkdir -p $(dirname "$CONF_PATH")
+        export CONF_PATH="$HOME/.ccache/ccache.conf"
+        
+        # Apply common settings
         echo "max_size = ${{ inputs.max_size }}" > "$CONF_PATH"
         echo "hash_dir = ${{ inputs.hash_dir }}" >> "$CONF_PATH"
         echo "compiler_check = ${{ inputs.compiler_check }}" >> "$CONF_PATH"
+        
+        if [ "${{ inputs.is_main_branch }}" == "true" ]; then
+          # Main branch: use main branch cache
+          ccache --set-config=cache_dir="${{ inputs.main_cache_dir }}"
+          echo "CCACHE_DIR=${{ inputs.main_cache_dir }}" >> $GITHUB_ENV
+        else
+          # Feature branch: use current branch cache with main as secondary
+          ccache --set-config=cache_dir="${{ inputs.current_cache_dir }}"
+          ccache --set-config=secondary_storage="file:${{ inputs.main_cache_dir }}"
+          echo "CCACHE_DIR=${{ inputs.current_cache_dir }}" >> $GITHUB_ENV
+        fi
+        
         ccache -p # Print config for verification
         ccache -z # Zero statistics before the build

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

@@ -21,7 +21,7 @@ inputs:
     required: false
     default: ''
   compiler-id:
-    description: 'Unique identifier for compiler/version combination used for cache keys'
+    description: 'Unique identifier: compiler-version-stdlib[-gccversion] (e.g. clang-14-libstdcxx-gcc11, gcc-13-libstdcxx)'
     required: false
     default: ''
   cache_version:
@@ -36,6 +36,17 @@ inputs:
     description: 'Main branch name for restore keys'
     required: false
     default: 'dev'
+  stdlib:
+    description: 'C++ standard library to use'
+    required: true
+    type: choice
+    options:
+      - libstdcxx
+      - libcxx
+  clang_gcc_toolchain:
+    description: 'GCC version to use for Clang toolchain (e.g. 11, 13)'
+    required: false
+    default: ''
 
 runs:
   using: 'composite'
@@ -48,18 +59,28 @@ runs:
         SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr -c 'a-zA-Z0-9_.-' '-')
         echo "name=${SAFE_BRANCH}" >> $GITHUB_OUTPUT
 
-    - name: Restore ccache directory
+    - name: Restore ccache directory for default branch
       if: inputs.ccache_enabled == 'true'
       id: ccache-restore
       uses: actions/cache/restore@v4
       with:
-        path: ~/.ccache
+        path: ~/.ccache-main
+        key: ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ inputs.main_branch }}
+        restore-keys: |
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
+
+    - name: Restore ccache directory for current branch
+      if: inputs.ccache_enabled == 'true' && steps.safe-branch.outputs.name != inputs.main_branch
+      id: ccache-restore-current-branch
+      uses: actions/cache/restore@v4
+      with:
+        path: ~/.ccache-current
         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
@@ -76,16 +97,54 @@ runs:
           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
         
+        # Configure C++ standard library if specified
+        # libstdcxx used for clang-14/16 to work around missing lexicographical_compare_three_way in libc++
+        # libcxx can be used with clang-17+ which has full C++20 support
+        # Note: -stdlib flag is Clang-specific, GCC always uses libstdc++
+        CMAKE_CXX_FLAGS=""
+        if [[ "${{ inputs.cxx }}" == clang* ]]; then
+          # Only Clang needs the -stdlib flag
+          if [ "${{ inputs.stdlib }}" = "libstdcxx" ]; then
+            CMAKE_CXX_FLAGS="-stdlib=libstdc++"
+          elif [ "${{ inputs.stdlib }}" = "libcxx" ]; then
+            CMAKE_CXX_FLAGS="-stdlib=libc++"
+          fi
+        fi
+        # GCC always uses libstdc++ and doesn't need/support the -stdlib flag
+        
+        # Configure GCC toolchain for Clang if specified
+        if [ -n "${{ inputs.clang_gcc_toolchain }}" ] && [[ "${{ inputs.cxx }}" == clang* ]]; then
+          # Extract Clang version from compiler executable name (e.g., clang++-14 -> 14)
+          clang_version=$(echo "${{ inputs.cxx }}" | grep -oE '[0-9]+$')
+          
+          # Clang 16+ supports --gcc-install-dir (precise path specification)
+          # Clang <16 only has --gcc-toolchain (uses discovery heuristics)
+          if [ -n "$clang_version" ] && [ "$clang_version" -ge "16" ]; then
+            # Clang 16+ uses --gcc-install-dir (canonical, precise)
+            CMAKE_CXX_FLAGS="$CMAKE_CXX_FLAGS --gcc-install-dir=/usr/lib/gcc/x86_64-linux-gnu/${{ inputs.clang_gcc_toolchain }}"
+          else
+            # Clang 14-15 uses --gcc-toolchain (deprecated but necessary)
+            # Note: This still uses discovery, so we hide newer GCC versions in the workflow
+            CMAKE_CXX_FLAGS="$CMAKE_CXX_FLAGS --gcc-toolchain=/usr"
+          fi
+        fi
+        
         # Run CMake configure
+        # Note: conanfile.py hardcodes 'build/generators' as the output path.
+        # If we're in a 'build' folder, Conan detects this and uses just 'generators/'
+        # If we're in '.build' (non-standard), Conan adds the full 'build/generators/'
+        # So we get: .build/build/generators/ with our non-standard folder name
         cmake .. \
           -G "${{ inputs.generator }}" \
           $CCACHE_ARGS \
+          ${CMAKE_CXX_FLAGS:+-DCMAKE_CXX_FLAGS="$CMAKE_CXX_FLAGS"} \
           -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
           -DCMAKE_BUILD_TYPE=${{ inputs.configuration }}
 
@@ -100,9 +159,16 @@ runs:
       shell: bash
       run: ccache -s
 
-    - name: Save ccache directory
-      if: inputs.ccache_enabled == 'true'
+    - name: Save ccache directory for default branch
+      if: always() && inputs.ccache_enabled == 'true' && steps.safe-branch.outputs.name == inputs.main_branch
       uses: actions/cache/save@v4
       with:
-        path: ~/.ccache
-        key: ${{ steps.ccache-restore.outputs.cache-primary-key }}
+        path: ~/.ccache-main
+        key: ${{ steps.ccache-restore.outputs.cache-primary-key }}
+
+    - name: Save ccache directory for current branch
+      if: always() && inputs.ccache_enabled == 'true' && steps.safe-branch.outputs.name != inputs.main_branch
+      uses: actions/cache/save@v4
+      with:
+        path: ~/.ccache-current
+        key: ${{ steps.ccache-restore-current-branch.outputs.cache-primary-key }}

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

@@ -10,7 +10,7 @@ inputs:
     required: false
     default: '.build'
   compiler-id:
-    description: 'Unique identifier for compiler/version combination used for cache keys'
+    description: 'Unique identifier: compiler-version-stdlib[-gccversion] (e.g. clang-14-libstdcxx-gcc11, gcc-13-libstdcxx)'
     required: false
     default: ''
   cache_version:
@@ -25,6 +25,13 @@ inputs:
     description: 'Main branch name for restore keys'
     required: false
     default: 'dev'
+  stdlib:
+    description: 'C++ standard library for Conan configuration (note: also in compiler-id)'
+    required: true
+    type: choice
+    options:
+      - libstdcxx
+      - libcxx
 
 outputs:
   cache-hit:
@@ -42,6 +49,26 @@ runs:
         SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr -c 'a-zA-Z0-9_.-' '-')
         echo "name=${SAFE_BRANCH}" >> $GITHUB_OUTPUT
 
+    - name: Check conanfile changes
+      if: inputs.cache_enabled == 'true'
+      id: check-conanfile-changes
+      shell: bash
+      run: |
+        # Check if we're on the main branch
+        if [ "${{ github.ref_name }}" == "${{ inputs.main_branch }}" ]; then
+          echo "should-save-conan-cache=true" >> $GITHUB_OUTPUT
+        else
+          # Fetch main branch for comparison
+          git fetch origin ${{ inputs.main_branch }}
+          
+          # Check if conanfile.txt or conanfile.py has changed compared to main branch
+          if git diff --quiet origin/${{ inputs.main_branch }}..HEAD -- '**/conanfile.txt' '**/conanfile.py'; then
+            echo "should-save-conan-cache=false" >> $GITHUB_OUTPUT
+          else
+            echo "should-save-conan-cache=true" >> $GITHUB_OUTPUT
+          fi
+        fi
+
     - name: Restore Conan cache
       if: inputs.cache_enabled == 'true'
       id: cache-restore-conan
@@ -50,20 +77,23 @@ runs:
         path: |
           ~/.conan
           ~/.conan2
+        # Note: compiler-id format is compiler-version-stdlib[-gccversion]
         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@
+        conan export external/snappy --version 1.1.10 --user xahaud --channel stable
+        conan export external/soci --version 4.0.3 --user xahaud --channel stable
+        conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable
 
     - name: Install dependencies
       shell: bash
+      env:
+        CONAN_REQUEST_TIMEOUT: 180  # Increase timeout to 3 minutes for slow mirrors
       run: |
         # Create build directory
         mkdir -p ${{ inputs.build_dir }}
@@ -77,10 +107,10 @@ runs:
           ..
 
     - name: Save Conan cache
-      if: inputs.cache_enabled == 'true' && steps.cache-restore-conan.outputs.cache-hit != 'true'
+      if: always() && inputs.cache_enabled == 'true' && steps.cache-restore-conan.outputs.cache-hit != 'true' && steps.check-conanfile-changes.outputs.should-save-conan-cache == 'true'
       uses: actions/cache/save@v4
       with:
         path: |
           ~/.conan
           ~/.conan2
-        key: ${{ steps.cache-restore-conan.outputs.cache-primary-key }}
+        key: ${{ steps.cache-restore-conan.outputs.cache-primary-key }}

.github/pull_request_template.md

@@ -33,7 +33,6 @@ 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)
@@ -59,12 +58,6 @@ 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

@@ -32,19 +32,9 @@ jobs:
           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
-
   build:
     runs-on: [self-hosted, vanity]
-    needs: [checkpatterns, checkout]
+    needs: [checkout]
     defaults:
       run:
         working-directory: ${{ needs.checkout.outputs.checkout_path }}

.github/workflows/checkpatterns.yml

@@ -1,20 +0,0 @@
-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/verify-generated-headers.yml

@@ -0,0 +1,36 @@
+name: Verify Generated Hook Headers
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  verify-generated-headers:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: hook/error.h
+            generator: ./hook/generate_error.sh
+          - target: hook/extern.h
+            generator: ./hook/generate_extern.sh
+          - target: hook/sfcodes.h
+            generator: bash ./hook/generate_sfcodes.sh
+          - target: hook/tts.h
+            generator: ./hook/generate_tts.sh
+    runs-on: ubuntu-latest
+    name: ${{ matrix.target }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Verify ${{ matrix.target }}
+        run: |
+          set -euo pipefail
+          chmod +x hook/generate_*.sh || true
+
+          tmp=$(mktemp)
+          trap 'rm -f "$tmp"' EXIT
+
+          ${{ matrix.generator }} > "$tmp"
+          diff -u ${{ matrix.target }} "$tmp"

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

@@ -5,6 +5,8 @@ on:
     branches: ["dev", "candidate", "release"]
   pull_request:
     branches: ["dev", "candidate", "release"]
+  schedule:
+    - cron: '0 0 * * *'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -30,9 +32,9 @@ jobs:
 
       - 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
+          brew install conan
+          # Verify Conan 2 is installed
+          conan --version
 
       - name: Install Coreutils
         run: |
@@ -58,12 +60,20 @@ jobs:
 
       - name: Install CMake
         run: |
-          if which cmake > /dev/null 2>&1; then
-              echo "cmake executable exists"
-              cmake --version
-          else
-              brew install cmake
-          fi
+          # Install CMake 3.x to match local dev environments
+          # With Conan 2 and the policy args passed to CMake, newer versions
+          # can have issues with dependencies that require cmake_minimum_required < 3.5
+          brew uninstall cmake --ignore-dependencies 2>/dev/null || true
+
+          # Download and install CMake 3.31.7 directly
+          curl -L https://github.com/Kitware/CMake/releases/download/v3.31.7/cmake-3.31.7-macos-universal.tar.gz -o cmake.tar.gz
+          tar -xzf cmake.tar.gz
+
+          # Move the entire CMake.app to /Applications
+          sudo mv cmake-3.31.7-macos-universal/CMake.app /Applications/
+
+          echo "/Applications/CMake.app/Contents/bin" >> $GITHUB_PATH
+          /Applications/CMake.app/Contents/bin/cmake --version
 
       - name: Install ccache
         run: brew install ccache
@@ -74,6 +84,7 @@ jobs:
           max_size: 2G
           hash_dir: true
           compiler_check: content
+          is_main_branch: ${{ github.ref_name == env.MAIN_BRANCH_NAME }}
 
       - name: Check environment
         run: |
@@ -89,8 +100,30 @@ jobs:
 
       - name: Configure Conan
         run: |
-          conan profile new default --detect || true # Ignore error if profile exists
-          conan profile update settings.compiler.cppstd=20 default
+          # Create the default profile directory if it doesn't exist
+          mkdir -p ~/.conan2/profiles
+
+          # Detect compiler version
+          COMPILER_VERSION=$(clang --version | grep -oE 'version [0-9]+' | grep -oE '[0-9]+')
+
+          # Create profile with our specific settings
+          cat > ~/.conan2/profiles/default <<EOF
+          [settings]
+          arch=armv8
+          build_type=Release
+          compiler=apple-clang
+          compiler.cppstd=20
+          compiler.libcxx=libc++
+          compiler.version=${COMPILER_VERSION}
+          os=Macos
+
+          [conf]
+          # Workaround for gRPC with newer Apple Clang
+          tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
+          EOF
+
+          # Display profile for verification
+          conan profile show
 
       - name: Install dependencies
         uses: ./.github/actions/xahau-ga-dependencies
@@ -113,4 +146,4 @@ jobs:
 
       - name: Test
         run: |
-          ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)
+          ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)

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

@@ -5,30 +5,158 @@ on:
     branches: ["dev", "candidate", "release"]
   pull_request:
     branches: ["dev", "candidate", "release"]
+  schedule:
+    - cron: '0 0 * * *'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
-  build-job:
+  matrix-setup:
+    runs-on: ubuntu-latest
+    container: python:3-slim
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - name: Generate build matrix
+        id: set-matrix
+        shell: python
+        run: |
+          import json
+          import os
+          
+          # Full matrix with all 6 compiler configurations
+          # Each configuration includes all parameters needed by the build job
+          full_matrix = [
+              {
+                  "compiler_id": "gcc-11-libstdcxx",
+                  "compiler": "gcc",
+                  "cc": "gcc-11",
+                  "cxx": "g++-11",
+                  "compiler_version": 11,
+                  "stdlib": "libstdcxx",
+                  "configuration": "Debug"
+              },
+              {
+                  "compiler_id": "gcc-13-libstdcxx",
+                  "compiler": "gcc",
+                  "cc": "gcc-13",
+                  "cxx": "g++-13",
+                  "compiler_version": 13,
+                  "stdlib": "libstdcxx",
+                  "configuration": "Debug"
+              },
+              {
+                  "compiler_id": "clang-14-libstdcxx-gcc11",
+                  "compiler": "clang",
+                  "cc": "clang-14",
+                  "cxx": "clang++-14",
+                  "compiler_version": 14,
+                  "stdlib": "libstdcxx",
+                  "clang_gcc_toolchain": 11,
+                  "configuration": "Debug"
+              },
+              {
+                  "compiler_id": "clang-16-libstdcxx-gcc13",
+                  "compiler": "clang",
+                  "cc": "clang-16",
+                  "cxx": "clang++-16",
+                  "compiler_version": 16,
+                  "stdlib": "libstdcxx",
+                  "clang_gcc_toolchain": 13,
+                  "configuration": "Debug"
+              },
+              {
+                  "compiler_id": "clang-17-libcxx",
+                  "compiler": "clang",
+                  "cc": "clang-17",
+                  "cxx": "clang++-17",
+                  "compiler_version": 17,
+                  "stdlib": "libcxx",
+                  "configuration": "Debug"
+              },
+              {
+                  # Clang 18 - testing if it's faster than Clang 17 with libc++
+                  # Requires patching Conan v1 settings.yml to add version 18
+                  "compiler_id": "clang-18-libcxx",
+                  "compiler": "clang",
+                  "cc": "clang-18",
+                  "cxx": "clang++-18",
+                  "compiler_version": 18,
+                  "stdlib": "libcxx",
+                  "configuration": "Debug"
+              }
+          ]
+          
+          # Minimal matrix for PRs and feature branches
+          minimal_matrix = [
+              full_matrix[1],  # gcc-13 (middle-ground gcc)
+              full_matrix[2]   # clang-14 (mature, stable clang)
+          ]
+          
+          # Determine which matrix to use based on the target branch
+          ref = "${{ github.ref }}"
+          base_ref = "${{ github.base_ref }}"  # For PRs, this is the target branch
+          event_name = "${{ github.event_name }}"
+          commit_message = """${{ github.event.head_commit.message }}"""
+          pr_title = """${{ github.event.pull_request.title }}"""
+          
+          # Debug logging
+          print(f"Event: {event_name}")
+          print(f"Ref: {ref}")
+          print(f"Base ref: {base_ref}")
+          print(f"PR title: {pr_title}")
+          print(f"Commit message: {commit_message}")
+          
+          # Check for override tags in commit message or PR title
+          force_full = "[ci-nix-full-matrix]" in commit_message or "[ci-nix-full-matrix]" in pr_title
+          print(f"Force full matrix: {force_full}")
+          
+          # Check if this is targeting a main branch
+          # For PRs: check base_ref (target branch)
+          # For pushes: check ref (current branch)
+          main_branches = ["refs/heads/dev", "refs/heads/release", "refs/heads/candidate"]
+          
+          if force_full:
+              # Override: always use full matrix if tag is present
+              use_full = True
+          elif event_name == "pull_request":
+              # For PRs, base_ref is just the branch name (e.g., "dev", not "refs/heads/dev")
+              # Check if the PR targets release or candidate (more critical branches)
+              use_full = base_ref in ["release", "candidate"]
+          else:
+              # For pushes, ref is the full reference (e.g., "refs/heads/dev")
+              use_full = ref in main_branches
+          
+          # Select the appropriate matrix
+          if use_full:
+              if force_full:
+                  print(f"Using FULL matrix (6 configs) - forced by [ci-nix-full-matrix] tag")
+              else:
+                  print(f"Using FULL matrix (6 configs) - targeting main branch")
+              matrix = full_matrix
+          else:
+              print(f"Using MINIMAL matrix (2 configs) - feature branch/PR")
+              matrix = minimal_matrix
+          
+          # Output the matrix as JSON
+          output = json.dumps({"include": matrix})
+          with open(os.environ['GITHUB_OUTPUT'], 'a') as f:
+              f.write(f"matrix={output}\n")
+
+  build:
+    needs: matrix-setup
     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
+      matrix: ${{ fromJSON(needs.matrix-setup.outputs.matrix) }}
     env:
       build_dir: .build
       # Bump this number to invalidate all caches globally.
-      CACHE_VERSION: 1
+      CACHE_VERSION: 2
       MAIN_BRANCH_NAME: dev
     steps:
       - name: Checkout
@@ -38,8 +166,70 @@ jobs:
         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"
+
+          # Install the specific GCC version needed for Clang
+          if [ -n "${{ matrix.clang_gcc_toolchain }}" ]; then
+            echo "=== Installing GCC ${{ matrix.clang_gcc_toolchain }} for Clang ==="
+            sudo apt-get install -y gcc-${{ matrix.clang_gcc_toolchain }} g++-${{ matrix.clang_gcc_toolchain }} libstdc++-${{ matrix.clang_gcc_toolchain }}-dev
+
+            echo "=== GCC versions available after installation ==="
+            ls -la /usr/lib/gcc/x86_64-linux-gnu/ | grep -E "^d"
+          fi
+
+          # For Clang < 16 with --gcc-toolchain, hide newer GCC versions
+          # This is needed because --gcc-toolchain still picks the highest version
+          #
+          # THE GREAT GCC HIDING TRICK (for Clang < 16):
+          # Clang versions before 16 don't have --gcc-install-dir, only --gcc-toolchain
+          # which is deprecated and still uses discovery heuristics that ALWAYS pick
+          # the highest version number. So we play a sneaky game...
+          #
+          # We rename newer GCC versions to very low integers (1, 2, 3...) which makes
+          # Clang think they're ancient GCC versions. Since 11 > 3 > 2 > 1, Clang will
+          # pick GCC 11 over our renamed versions. It's dumb but it works!
+          #
+          # Example: GCC 12→1, GCC 13→2, GCC 14→3, so Clang picks 11 (highest number)
+          if [ -n "${{ matrix.clang_gcc_toolchain }}" ] && [ "${{ matrix.compiler_version }}" -lt "16" ]; then
+            echo "=== Hiding GCC versions newer than ${{ matrix.clang_gcc_toolchain }} for Clang < 16 ==="
+            target_version=${{ matrix.clang_gcc_toolchain }}
+            counter=1  # Start with 1 - these will be seen as "GCC version 1, 2, 3" etc
+            for dir in /usr/lib/gcc/x86_64-linux-gnu/*/; do
+              if [ -d "$dir" ]; then
+                version=$(basename "$dir")
+                # Check if version is numeric and greater than target
+                if [[ "$version" =~ ^[0-9]+$ ]] && [ "$version" -gt "$target_version" ]; then
+                  echo "Hiding GCC $version -> renaming to $counter (will be seen as GCC version $counter)"
+                  # Safety check: ensure target doesn't already exist
+                  if [ ! -e "/usr/lib/gcc/x86_64-linux-gnu/$counter" ]; then
+                    sudo mv "$dir" "/usr/lib/gcc/x86_64-linux-gnu/$counter"
+                  else
+                    echo "ERROR: Cannot rename GCC $version - /usr/lib/gcc/x86_64-linux-gnu/$counter already exists"
+                    exit 1
+                  fi
+                  counter=$((counter + 1))
+                fi
+              fi
+            done
+          fi
+
+          # Verify what Clang will use
+          if [ -n "${{ matrix.clang_gcc_toolchain }}" ]; then
+            echo "=== Verifying GCC toolchain selection ==="
+            echo "Available GCC versions:"
+            ls -la /usr/lib/gcc/x86_64-linux-gnu/ | grep -E "^d.*[0-9]+$" || true
+
+            echo ""
+            echo "Clang's detected GCC installation:"
+            ${{ matrix.cxx }} -v -E -x c++ /dev/null -o /dev/null 2>&1 | grep "Found candidate GCC installation" || true
+          fi
+
+          # Install libc++ dev packages if using libc++ (not needed for libstdc++)
+          if [ "${{ matrix.stdlib }}" = "libcxx" ]; then
+            sudo apt-get install -y libc++-${{ matrix.compiler_version }}-dev libc++abi-${{ matrix.compiler_version }}-dev
+          fi
+
+          # Install Conan 2
+          pip install --upgrade "conan>=2.0,<3"
 
       - name: Configure ccache
         uses: ./.github/actions/xahau-configure-ccache
@@ -47,25 +237,41 @@ jobs:
           max_size: 2G
           hash_dir: true
           compiler_check: content
+          is_main_branch: ${{ github.ref_name == env.MAIN_BRANCH_NAME }}
 
       - 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
+          # Create the default profile directory if it doesn't exist
+          mkdir -p ~/.conan2/profiles
 
-          # 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
+          # Determine the correct libcxx based on stdlib parameter
+          if [ "${{ matrix.stdlib }}" = "libcxx" ]; then
+            LIBCXX="libc++"
+          else
+            LIBCXX="libstdc++11"
           fi
+
+          # Create profile with our specific settings
+          cat > ~/.conan2/profiles/default <<EOF
+          [settings]
+          arch=x86_64
+          build_type=${{ matrix.configuration }}
+          compiler=${{ matrix.compiler }}
+          compiler.cppstd=20
+          compiler.libcxx=${LIBCXX}
+          compiler.version=${{ matrix.compiler_version }}
+          os=Linux
+
+          [buildenv]
+          CC=/usr/bin/${{ matrix.cc }}
+          CXX=/usr/bin/${{ matrix.cxx }}
+
+          [conf]
+          tools.build:compiler_executables={"c": "/usr/bin/${{ matrix.cc }}", "cpp": "/usr/bin/${{ matrix.cxx }}"}
+          EOF
+
           # Display profile for verification
-          conan profile show default
+          conan profile show
 
       - name: Check environment
         run: |
@@ -87,6 +293,7 @@ jobs:
           compiler-id: ${{ matrix.compiler_id }}
           cache_version: ${{ env.CACHE_VERSION }}
           main_branch: ${{ env.MAIN_BRANCH_NAME }}
+          stdlib: ${{ matrix.stdlib }}
 
       - name: Build
         uses: ./.github/actions/xahau-ga-build
@@ -99,6 +306,8 @@ jobs:
           compiler-id: ${{ matrix.compiler_id }}
           cache_version: ${{ env.CACHE_VERSION }}
           main_branch: ${{ env.MAIN_BRANCH_NAME }}
+          stdlib: ${{ matrix.stdlib }}
+          clang_gcc_toolchain: ${{ matrix.clang_gcc_toolchain || '' }}
 
       - name: Set artifact name
         id: set-artifact-name
@@ -120,4 +329,4 @@ jobs:
           else
              echo "Error: rippled executable not found in ${{ env.build_dir }}"
              exit 1
-          fi
+          fi

.gitignore

@@ -24,6 +24,11 @@ bin/project-cache.jam
 
 build/docker
 
+# Ignore release builder files
+.env
+release-build
+cmake-*.tar.gz
+
 # Ignore object files.
 *.o
 build
@@ -116,7 +121,3 @@ CMakeUserPresets.json
 bld.rippled/
 
 generated
-.vscode
-
-# Suggested in-tree build directory
-/.build/

.vscode/settings.json

@@ -8,6 +8,6 @@
     "editor.semanticHighlighting.enabled": true,
     "editor.tabSize": 4,
     "editor.defaultFormatter": "xaver.clang-format",
-    "editor.formatOnSave": false
+    "editor.formatOnSave": true
   }
 }

API-CHANGELOG.md

@@ -1,199 +0,0 @@
-# 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,7 +1,7 @@
-| :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 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 [our 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)
@@ -29,14 +29,11 @@ branch.
 git checkout develop
 ```
 
+
 ## Minimum Requirements
 
-See [System Requirements](https://xrpl.org/system-requirements.html).
-
-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).
-
 - [Python 3.7](https://www.python.org/downloads/)
-- [Conan 1.55](https://conan.io/downloads.html)
+- [Conan 2.x](https://conan.io/downloads)
 - [CMake 3.16](https://cmake.org/download/)
 
 `rippled` is written in the C++20 dialect and includes the `<concepts>` header.
@@ -44,121 +41,113 @@ The [minimum compiler versions][2] required are:
 
 | Compiler    | Version |
 |-------------|---------|
-| GCC         | 11      |
+| GCC         | 10      |
 | Clang       | 13      |
 | Apple Clang | 13.1.6  |
 | MSVC        | 19.23   |
 
-### Linux
+We don't recommend Windows for `rippled` production at this time. As of
+January 2023, Ubuntu has the highest level of quality assurance, testing,
+and support.
 
-The Ubuntu operating system has received the highest level of
-quality assurance, testing, and support.
+Windows developers should use Visual Studio 2019. `rippled` isn't
+compatible with [Boost](https://www.boost.org/) 1.78 or 1.79, and Conan
+can't build earlier Boost versions.
 
-Here are [sample instructions for setting up a C++ development environment on Linux](./docs/build/environment.md#linux).
+**Note:** 32-bit Windows development isn't supported.
 
-### 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
 
+
 ### Set Up Conan
 
-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.
-
-These instructions assume a basic familiarity with Conan and CMake.
-
-If you are unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official [Getting Started][3] walkthrough.
-
-You'll need at least one Conan profile:
+1. (Optional) If you've never used Conan, use autodetect to set up a default profile.
 
    ```
-   conan profile new default --detect
+   conan profile detect --force
    ```
 
-Update the compiler settings:
+2. Update the compiler settings.
+
+   For Conan 2, you can edit the profile directly at `~/.conan2/profiles/default`,
+   or use the Conan CLI. Ensure C++20 is set:
 
    ```
-   conan profile update settings.compiler.cppstd=20 default
+   conan profile show
    ```
 
-**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:
+   Look for `compiler.cppstd=20` in the output. If it's not set, edit the profile:
 
    ```
-   conan profile update settings.compiler.libcxx=libstdc++11 default
+   # Edit ~/.conan2/profiles/default and ensure these settings exist:
+   [settings]
+   compiler.cppstd=20
    ```
 
-**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.
+   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.
+
+   ```
+   # In ~/.conan2/profiles/default, ensure:
+   [settings]
+   compiler.libcxx=libstdc++11
+   ```
+
+   On Windows, you should 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 also build `rippled` and its dependencies for the x64
-   architecture:
+   architecture.
 
    ```
-   conan profile update settings.arch=x86_64 default
+   # In ~/.conan2/profiles/default, ensure:
+   [settings]
+   arch=x86_64
    ```
 
-### 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 '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.
-
-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:
-
-- `conan profile update env.CC=<path> default`
-- `conan profile update env.CXX=<path> default`
-
-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.
+3. (Optional) If you have multiple compilers installed on your platform,
+   make sure that Conan and CMake select the one you want to use.
+   This setting will set the correct variables (`CMAKE_<LANG>_COMPILER`)
+   in the generated CMake toolchain file.
 
    ```
-   conan export external/snappy snappy/1.1.9@
+   # In ~/.conan2/profiles/default, add under [conf] section:
+   [conf]
+   tools.build:compiler_executables={"c": "<path>", "cpp": "<path>"}
    ```
 
-Export our [Conan recipe for RocksDB](./external/rocksdb).
-It does not override paths to dependencies when building with Visual Studio.
+   For setting environment variables for dependencies:
 
    ```
-   conan export external/rocksdb rocksdb/6.29.5@
+   # In ~/.conan2/profiles/default, add under [buildenv] section:
+   [buildenv]
+   CC=<path>
+   CXX=<path>
    ```
 
-Export our [Conan recipe for SOCI](./external/soci).
-It patches their CMake to correctly import its dependencies.
+4. Export our [Conan recipe for Snappy](./external/snappy).
+   It doesn't explicitly link the C++ standard library,
+   which allows you to statically link it with GCC, if you want.
 
    ```
-   conan export external/soci soci/4.0.3@
+   conan export external/snappy --version 1.1.10 --user xahaud --channel stable
+   ```
+
+5. Export our [Conan recipe for SOCI](./external/soci).
+   It patches their CMake to correctly import its dependencies.
+
+   ```
+   conan export external/soci --version 4.0.3 --user xahaud --channel stable
+   ```
+
+6. Export our [Conan recipe for WasmEdge](./external/wasmedge).
+
+   ```
+   conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable
    ```
 
 ### Build and Test
@@ -223,7 +212,7 @@ It patches their CMake to correctly import its dependencies.
     and make sure it matches the `build_type` setting you chose in the previous
     step.
 
-    Multi-config generators:
+    Multi-config gnerators:
 
     ```
     cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
@@ -269,72 +258,12 @@ It patches their CMake to correctly import its dependencies.
    generator. Pass `--help` to see the rest of the command line options.
 
 
-## Coverage report
-
-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`
-
-Prerequisites for the coverage report:
-
-- [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.
-
-
 ## Options
 
 | 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`. |
@@ -353,23 +282,26 @@ and can be helpful for detecting `#include` omissions.
 If you have trouble building dependencies after changing Conan settings,
 try removing the Conan cache.
 
+For Conan 2:
 ```
-rm -rf ~/.conan/data
+rm -rf ~/.conan2/p
+```
+
+Or clear the entire Conan 2 cache:
+```
+conan cache clean "*"
 ```
 
 
-### no std::result_of
+### macOS compilation with Apple Clang 17+
 
-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.
+If you're on macOS with Apple Clang 17 or newer, you need to add a compiler flag to work around a compilation error in gRPC dependencies.
+
+Edit `~/.conan2/profiles/default` and add under the `[conf]` section:
 
 ```
-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
+[conf]
+tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
 ```
 
 
@@ -524,10 +456,6 @@ 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
@@ -537,3 +465,4 @@ but it is more convenient to put them in a [profile][profile].
 [search]: https://cmake.org/cmake/help/latest/command/find_package.html#search-procedure
 [prefix_path]: https://cmake.org/cmake/help/latest/variable/CMAKE_PREFIX_PATH.html
 [profile]: https://docs.conan.io/en/latest/reference/profiles.html
+

Builds/CMake/CMakeFuncs.cmake

@@ -1,3 +1,4 @@
+
 macro(group_sources_in source_dir curdir)
   file(GLOB children RELATIVE ${source_dir}/${curdir}
     ${source_dir}/${curdir}/*)
@@ -28,8 +29,165 @@ 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 ()
@@ -46,3 +204,4 @@ function (git_branch branch_val)
   endif ()
   set (${branch_val} "${_branch}" PARENT_SCOPE)
 endfunction ()
+

Builds/CMake/CMake_sqlite3.txt

@@ -0,0 +1,60 @@
+
+#[=========================================================[
+  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

@@ -1,440 +0,0 @@
-# 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/RippledCompiler.cmake

@@ -130,16 +130,7 @@ else ()
       >)
 endif ()
 
-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)
+if (use_gold AND is_gcc)
   # use gold linker if available
   execute_process (
     COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
@@ -171,7 +162,9 @@ elseif (use_gold AND is_gcc)
         $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
   endif ()
   unset (LD_VERSION)
-elseif (use_lld)
+endif ()
+
+if (use_lld)
   # use lld linker if available
   execute_process (
     COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
@@ -182,7 +175,6 @@ elseif (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,53 +3,9 @@
    core functionality, useable by some client software perhaps
 #]===================================================================]
 
-include(target_protobuf_sources)
-
 file (GLOB_RECURSE rb_headers
-  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++
-)
+  src/ripple/beast/*.h
+  src/ripple/beast/*.hpp)
 
 add_library (xrpl_core
   ${rb_headers}) ## headers added here for benefit of IDEs
@@ -71,15 +27,16 @@ 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
@@ -93,29 +50,28 @@ target_sources (xrpl_core PRIVATE
   src/ripple/beast/utility/src/beast_Journal.cpp
   src/ripple/beast/utility/src/beast_PropertyStream.cpp)
 
+# Conditionally add enhanced logging source when BEAST_ENHANCED_LOGGING is enabled
+if(DEFINED BEAST_ENHANCED_LOGGING AND BEAST_ENHANCED_LOGGING)
+  target_sources(xrpl_core PRIVATE
+    src/ripple/beast/utility/src/beast_EnhancedLogging.cpp)
+endif()
+
 #[===============================[
     core sources
 #]===============================]
 target_sources (xrpl_core PRIVATE
   #[===============================[
     main sources:
-      subdir: basics
+      subdir: basics (partial)
   #]===============================]
-  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
@@ -134,7 +90,6 @@ 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
@@ -142,14 +97,10 @@ 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
@@ -159,15 +110,12 @@ 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
@@ -181,23 +129,6 @@ 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
@@ -205,7 +136,6 @@ 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
@@ -223,71 +153,51 @@ 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
-    xrpl.libpb
-    xxHash::xxhash)
+    ed25519::ed25519
+    date::date
+    Ripple::opts)
+
+# Link date-tz library when enhanced logging is enabled
+if(DEFINED BEAST_ENHANCED_LOGGING AND BEAST_ENHANCED_LOGGING)
+  if(TARGET date::date-tz)
+    target_link_libraries(xrpl_core PUBLIC date::date-tz)
+  endif()
+endif()
 #[=================================[
    main/core headers installation
 #]=================================]
-# BEGIN LIBXRPL HEADERS
 install (
   FILES
-    src/ripple/basics/Archive.h
-    src/ripple/basics/BasicConfig.h
+    src/ripple/basics/base64.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/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/safe_cast.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
@@ -314,42 +224,25 @@ 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/json_get_or_throw.h
-    src/ripple/protocol/Keylet.h
     src/ripple/protocol/KeyType.h
+    src/ripple/protocol/Keylet.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
@@ -357,10 +250,8 @@ 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
@@ -368,72 +259,27 @@ install (
     src/ripple/protocol/STTx.h
     src/ripple/protocol/STValidation.h
     src/ripple/protocol/STVector256.h
-    src/ripple/protocol/STXChainBridge.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/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/b58_utils.h
+    src/ripple/protocol/impl/STVar.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
 #]===================================]
@@ -445,7 +291,6 @@ 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
@@ -457,13 +302,8 @@ install (
     src/ripple/beast/hash/xxhasher.h
   DESTINATION include/ripple/beast/hash)
 install (
-  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)
+  FILES src/ripple/beast/hash/impl/xxhash.h
+  DESTINATION include/ripple/beast/hash/impl)
 install (
   FILES
     src/ripple/beast/rfc2616.h
@@ -471,34 +311,37 @@ 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)
-# END LIBXRPL HEADERS
+# 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
 #[===================================================================[
    rippled executable
 #]===================================================================]
@@ -515,7 +358,6 @@ endif ()
 if (tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
 endif()
-# BEGIN XRPLD SOURCES
 target_sources (rippled PRIVATE
   #[===============================[
      main sources:
@@ -562,8 +404,6 @@ 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
@@ -574,7 +414,6 @@ target_sources (rippled PRIVATE
   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
@@ -591,8 +430,6 @@ 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
@@ -609,12 +446,6 @@ 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
@@ -626,10 +457,9 @@ target_sources (rippled PRIVATE
   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/Cron.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
@@ -645,13 +475,12 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/Payment.cpp
   src/ripple/app/tx/impl/Remit.cpp
   src/ripple/app/tx/impl/SetAccount.cpp
+  src/ripple/app/tx/impl/SetCron.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
@@ -659,7 +488,19 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/apply.cpp
   src/ripple/app/tx/impl/applySteps.cpp
   src/ripple/app/hook/impl/applyHook.cpp
+  src/ripple/app/hook/impl/HookAPI.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
@@ -677,7 +518,9 @@ 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
   #[===============================[
@@ -711,6 +554,7 @@ 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
   #[===============================[
@@ -720,7 +564,6 @@ target_sources (rippled PRIVATE
   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
@@ -762,6 +605,14 @@ 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
@@ -774,7 +625,6 @@ 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
@@ -789,7 +639,6 @@ 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
@@ -842,16 +691,26 @@ target_sources (rippled PRIVATE
   src/ripple/rpc/impl/RPCHandler.cpp
   src/ripple/rpc/impl/RPCHelpers.cpp
   src/ripple/rpc/impl/Role.cpp
-  src/ripple/rpc/impl/ServerHandler.cpp
+  src/ripple/rpc/impl/ServerHandlerImp.cpp
   src/ripple/rpc/impl/ShardArchiveHandler.cpp
   src/ripple/rpc/impl/ShardVerificationScheduler.cpp
   src/ripple/rpc/impl/Status.cpp
   src/ripple/rpc/impl/TransactionSign.cpp
+  src/ripple/rpc/impl/NFTokenID.cpp
+  src/ripple/rpc/impl/NFTokenOfferID.cpp
+  src/ripple/rpc/impl/NFTSyntheticSerializer.cpp
   #[===============================[
      main sources:
        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
@@ -865,7 +724,6 @@ 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:
@@ -876,18 +734,15 @@ 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/Cron_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
@@ -910,19 +765,17 @@ 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
     src/test/app/PayStrand_test.cpp
+    src/test/app/PreviousTxn_test.cpp
     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
@@ -961,7 +814,6 @@ 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
@@ -1040,24 +892,21 @@ 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/Oracle.cpp
-    src/test/jtx/impl/TestHelpers.cpp
+    src/test/jtx/impl/ManualTimeKeeper.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/cron.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
@@ -1082,9 +931,9 @@ if (tests)
     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/TestHelpers.cpp
     src/test/jtx/impl/ticket.cpp
     src/test/jtx/impl/token.cpp
     src/test/jtx/impl/trust.cpp
@@ -1117,6 +966,7 @@ if (tests)
     src/test/nodestore/Basics_test.cpp
     src/test/nodestore/DatabaseShard_test.cpp
     src/test/nodestore/Database_test.cpp
+    src/test/nodestore/NuDBFactory_test.cpp
     src/test/nodestore/Timing_test.cpp
     src/test/nodestore/import_test.cpp
     src/test/nodestore/varint_test.cpp
@@ -1141,13 +991,11 @@ 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
@@ -1165,33 +1013,35 @@ if (tests)
          subdir: resource
     #]===============================]
     src/test/resource/Logic_test.cpp
+    #[===============================[
+       test sources:
+         subdir: rdb
+    #]===============================]
+    src/test/rdb/RelationalDatabase_test.cpp
     #[===============================[
        test sources:
          subdir: rpc
     #]===============================]
     src/test/rpc/AccountCurrencies_test.cpp
     src/test/rpc/AccountInfo_test.cpp
-    src/test/rpc/AccountLines_test.cpp
+    src/test/rpc/AccountLinesRPC_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
@@ -1216,7 +1066,6 @@ 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
@@ -1242,6 +1091,11 @@ target_link_libraries (rippled
   Ripple::opts
   Ripple::libs
   Ripple::xrpl_core
+  # Workaround for a Conan 1.x bug that prevents static linking of libstdc++
+  # when a dependency (snappy) modifies system_libs. See the comment in
+  # external/snappy/conanfile.py for a full explanation.
+  # This is likely not strictly necessary, but listed explicitly as a good practice.
+  m
   )
 exclude_if_included (rippled)
 # define a macro for tests that might need to

Builds/CMake/RippledCov.cmake

@@ -2,37 +2,97 @@
    coverage report target
 #]===================================================================]
 
-if(NOT coverage)
-  message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
-endif()
+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(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-  message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
-  return()
-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 ()
 
-include(CodeCoverage)
+    set (extract_pattern "")
+    if (coverage_core_only)
+      set (extract_pattern "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/")
+    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`)
+    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 ()
 
-set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
-if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
-  separate_arguments(GCOVR_ADDITIONAL_ARGS)
-endif()
+    find_program (GENHTML genhtml)
+    if (NOT GENHTML)
+      message (WARNING "unable to find genhtml - skipping coverage_report target")
+    endif ()
 
-list(APPEND GCOVR_ADDITIONAL_ARGS
-  --exclude-throw-branches
-  --exclude-noncode-lines
-  --exclude-unreachable-branches -s
-  -j ${coverage_test_parallelism})
+    set (extract_pattern "*")
+    if (coverage_core_only)
+      set (extract_pattern "*/src/ripple/*")
+    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
-)
+    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 ()

Builds/CMake/RippledInstall.cmake

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

Builds/CMake/RippledInterface.cmake

@@ -23,15 +23,15 @@ 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}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-fprofile-arcs -ftest-coverage>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-fprofile-instr-generate -fcoverage-mapping>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-fprofile-arcs -ftest-coverage>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-fprofile-instr-generate -fcoverage-mapping>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 

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 xrpl_core rippled)
+  foreach (_target secp256k1::secp256k1 ed25519::ed25519 pbufs xrpl_core rippled)
     get_target_property (_type ${_target} TYPE)
     if(_type STREQUAL "INTERFACE_LIBRARY")
       continue()

Builds/CMake/RippledNIH.cmake

@@ -1,33 +0,0 @@
-#[===================================================================[
-   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,8 +2,6 @@
    convenience variables and sanity checks
 #]===================================================================]
 
-include(ProcessorCount)
-
 if (NOT ep_procs)
   ProcessorCount(ep_procs)
   if (ep_procs GREATER 1)

Builds/CMake/RippledSettings.cmake

@@ -2,129 +2,121 @@
    declare user options/settings
 #]===================================================================]
 
-include(ProcessorCount)
+option (assert "Enables asserts, even in release builds" OFF)
 
-ProcessorCount(PROCESSOR_COUNT)
+option (reporting "Build rippled with reporting mode enabled" OFF)
 
-option(assert "Enables asserts, even in release builds" OFF)
+option (tests "Build tests" ON)
 
-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
+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
     "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(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()
+  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 ()
   # 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)
-  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
+  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
   "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 master branch unless we are on release
-  if (NOT (current_branch STREQUAL "release"))
-    set (current_branch "master")
+  # 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")
   endif ()
   message (STATUS "tracking ValidatorKeys branch: ${current_branch}")
 

Builds/CMake/SociConfig.cmake.patched

@@ -0,0 +1,106 @@
+################################################################################
+# 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

@@ -1,54 +0,0 @@
-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,51 +1,3 @@
-#[===================================================================[
-   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
@@ -54,16 +6,15 @@ find_package(Boost 1.86 REQUIRED
     coroutine
     date_time
     filesystem
-    json
     program_options
     regex
     system
-    iostreams
-    thread)
+    thread
+)
 
 add_library(ripple_boost INTERFACE)
 add_library(Ripple::boost ALIAS ripple_boost)
-if(is_xcode)
+if(XCODE)
   target_include_directories(ripple_boost BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
   target_compile_options(ripple_boost INTERFACE --system-header-prefix="boost/")
 else()
@@ -78,11 +29,10 @@ target_link_libraries(ripple_boost
     Boost::coroutine
     Boost::date_time
     Boost::filesystem
-    Boost::json
-    Boost::iostreams
     Boost::program_options
     Boost::regex
     Boost::system
+    Boost::iostreams
     Boost::thread)
 if(Boost_COMPILER)
   target_link_libraries(ripple_boost INTERFACE Boost::disable_autolinking)

Builds/CMake/deps/Ed25519-donna.cmake

@@ -1,28 +0,0 @@
-#[===================================================================[
-   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

@@ -1,47 +0,0 @@
-# - 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

@@ -1,22 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,163 +0,0 @@
-#[===================================================================[
-   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

@@ -1,79 +0,0 @@
-#[===================================================================[
-   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

@@ -1,31 +0,0 @@
-#[===================================================================[
-   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

@@ -1,48 +0,0 @@
-#[===================================================================[
-   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

@@ -1,70 +0,0 @@
-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,156 +1,22 @@
-#[===================================================================[
-   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.
-#]===================================================================]
+find_package(Protobuf 3.8)
 
-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})
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/proto_gen)
 set(ccbd ${CMAKE_CURRENT_BINARY_DIR})
-set(CMAKE_CURRENT_BINARY_DIR ${output_dir})
+set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/proto_gen)
 protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS src/ripple/proto/ripple.proto)
 set(CMAKE_CURRENT_BINARY_DIR ${ccbd})
 
-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>
+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_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
+target_link_libraries(pbufs protobuf::libprotobuf)
+target_compile_options(pbufs
   PUBLIC
-    $<$<BOOL:${is_xcode}>:
+    $<$<BOOL:${XCODE}>:
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
     >
 )
+add_library(Ripple::pbufs ALIAS pbufs)

Builds/CMake/deps/Rocksdb.cmake

@@ -1,177 +0,0 @@
-#[===================================================================[
-   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

@@ -1,58 +0,0 @@
-#[===================================================================[
-   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

@@ -1,77 +0,0 @@
-#[===================================================================[
-   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

@@ -1,165 +0,0 @@
-#[===================================================================[
-   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

@@ -1,93 +0,0 @@
-#[===================================================================[
-   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

@@ -1,84 +1 @@
-#[===================================================================[
- NIH dep: wasmedge: web assembly runtime for hooks.
-#]===================================================================]
-
-find_package(Curses)
-if(CURSES_FOUND)
-  include_directories(${CURSES_INCLUDE_DIR})
-  target_link_libraries(ripple_libs INTERFACE ${CURSES_LIBRARY})
-else()
-  message(WARNING "CURSES library not found... (only important for mac builds)")
-endif()
-
-
-find_package(LLVM REQUIRED CONFIG)
-message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
-message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
-ExternalProject_Add (wasmedge_src
-  PREFIX ${nih_cache_path}
-  GIT_REPOSITORY https://github.com/WasmEdge/WasmEdge.git
-  GIT_TAG 0.11.2
-  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
-    -DWASMEDGE_BUILD_SHARED_LIB=OFF
-    -DWASMEDGE_BUILD_STATIC_LIB=ON
-    -DWASMEDGE_BUILD_AOT_RUNTIME=ON
-    -DWASMEDGE_FORCE_DISABLE_LTO=ON
-    -DWASMEDGE_LINK_LLVM_STATIC=ON
-    -DWASMEDGE_LINK_TOOLS_STATIC=ON
-    -DWASMEDGE_BUILD_PLUGINS=OFF
-    -DCMAKE_POSITION_INDEPENDENT_CODE=ON
-    -DLLVM_DIR=${LLVM_DIR}
-    -DLLVM_LIBRARY_DIR=${LLVM_LIBRARY_DIR}
-    -DLLVM_ENABLE_TERMINFO=OFF
-    $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
-    $<$<BOOL:${MSVC}>:
-      "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP -march=native"
-      "-DCMAKE_C_FLAGS_DEBUG=-MTd"
-      "-DCMAKE_C_FLAGS_RELEASE=-MT"
-    >  
-  LOG_CONFIGURE ON
-  LOG_BUILD ON
-  LOG_CONFIGURE ON
-  COMMAND
-    pwd
-  BUILD_COMMAND
-    ${CMAKE_COMMAND}
-    --build .
-    --config $<CONFIG>
-    $<$<VERSION_GREATER_EQUAL:${CMAKE_VERSION},3.12>:--parallel ${ep_procs}>
-  TEST_COMMAND ""
-  INSTALL_COMMAND ""
-  BUILD_BYPRODUCTS
-      <BINARY_DIR>/lib/api/libwasmedge.a
-)
-add_library (wasmedge STATIC IMPORTED GLOBAL)
-ExternalProject_Get_Property (wasmedge_src BINARY_DIR)
-ExternalProject_Get_Property (wasmedge_src SOURCE_DIR)
-set (wasmedge_src_BINARY_DIR "${BINARY_DIR}")
-add_dependencies (wasmedge wasmedge_src)
-execute_process(
-    COMMAND
-        mkdir -p "${wasmedge_src_BINARY_DIR}/include/api"
-)
-set_target_properties (wasmedge PROPERTIES
-  IMPORTED_LOCATION_DEBUG
-    "${wasmedge_src_BINARY_DIR}/lib/api/libwasmedge.a"
-  IMPORTED_LOCATION_RELEASE
-    "${wasmedge_src_BINARY_DIR}/lib/api/libwasmedge.a"
-  INTERFACE_INCLUDE_DIRECTORIES
-    "${wasmedge_src_BINARY_DIR}/include/api/"
-)
-target_link_libraries (ripple_libs INTERFACE wasmedge)
-#RH NOTE: some compilers / versions of some libraries need these, most don't
-
-find_library(XAR_LIBRARY NAMES xar)
-if(XAR_LIBRARY)
-  target_link_libraries(ripple_libs INTERFACE ${XAR_LIBRARY})
-else()
-  message(WARNING "xar library not found... (only important for mac builds)")
-endif()
-add_library (wasmedge::wasmedge ALIAS wasmedge)
+find_package(wasmedge REQUIRED)

Builds/CMake/deps/cassandra.cmake

@@ -1,167 +0,0 @@
-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

@@ -1,18 +0,0 @@
-#[===================================================================[
-   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,340 +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 ()
+find_package(gRPC 1.23)
 
 #[=================================[
    generate protobuf sources for
    grpc defs and bundle into a
    static lib
 #]=================================]
-set(output_dir "${CMAKE_BINARY_DIR}/proto_gen_grpc")
-set(GRPC_GEN_DIR "${output_dir}/ripple/proto")
+set(GRPC_GEN_DIR "${CMAKE_BINARY_DIR}/proto_gen_grpc")
 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 "${GRPC_PROTO_ROOT}/*.proto")
+file(GLOB_RECURSE GRPC_DEFINITION_FILES LIST_DIRECTORIES false "${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")
@@ -353,40 +36,27 @@ 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
-      SKIP_UNITY_BUILD_INCLUSION ON
-    )
+    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES GENERATED TRUE)
     list(APPEND GRPC_PROTO_SRCS ${src_1} ${src_2})
     list(APPEND GRPC_PROTO_HDRS ${hdr_1} ${hdr_2})
 endforeach()
 
-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
+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
   "gRPC::grpc++"
   # libgrpc is missing references.
   absl::random_random
 )
-target_compile_options(xrpl_core
+target_compile_options(grpc_pbufs
   PRIVATE
     $<$<BOOL:${MSVC}>:-wd4065>
     $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
   PUBLIC
     $<$<BOOL:${MSVC}>:-wd4996>
-    $<$<BOOL:${is_xcode}>:
+    $<$<BOOL:${XCODE}>:
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
     >)
-# target_link_libraries (ripple_libs INTERFACE Ripple::grpc_pbufs)
-# exclude_if_included (grpc_pbufs)
+add_library(Ripple::grpc_pbufs ALIAS grpc_pbufs)

Builds/CMake/echo_file.cmake

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

@@ -1,62 +0,0 @@
-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

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

Builds/levelization/results/ordering.txt

@@ -140,8 +140,6 @@ 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
@@ -168,6 +166,7 @@ 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
@@ -187,6 +186,10 @@ test.protocol > ripple.crypto
 test.protocol > ripple.json
 test.protocol > ripple.protocol
 test.protocol > test.toplevel
+test.rdb > ripple.app
+test.rdb > ripple.core
+test.rdb > test.jtx
+test.rdb > test.toplevel
 test.resource > ripple.basics
 test.resource > ripple.beast
 test.resource > ripple.resource

CMakeLists.txt

@@ -24,7 +24,7 @@ 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} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git describe --always --abbrev=40
+    execute_process(COMMAND ${GIT_EXECUTABLE} describe --always --abbrev=40
         OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
     if(gch)
         set(GIT_COMMIT_HASH "${gch}")
@@ -33,6 +33,25 @@ if(Git_FOUND)
     endif()
 endif() #git
 
+# make SOURCE_ROOT_PATH define available for logging
+set(SOURCE_ROOT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/src/")
+add_definitions(-DSOURCE_ROOT_PATH="${SOURCE_ROOT_PATH}")
+
+# BEAST_ENHANCED_LOGGING option - adds file:line numbers and formatting to logs
+# Default to ON for Debug builds, OFF for Release
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    option(BEAST_ENHANCED_LOGGING "Include file and line numbers in log messages" ON)
+else()
+    option(BEAST_ENHANCED_LOGGING "Include file and line numbers in log messages" OFF)
+endif()
+
+if(BEAST_ENHANCED_LOGGING)
+    add_definitions(-DBEAST_ENHANCED_LOGGING=1)
+    message(STATUS "Log line numbers enabled")
+else()
+    message(STATUS "Log line numbers disabled")
+endif()
+
 if(thread_safety_analysis)
   add_compile_options(-Wthread-safety -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS -DRIPPLE_ENABLE_THREAD_SAFETY_ANNOTATIONS)
   add_compile_options("-stdlib=libc++")
@@ -50,15 +69,11 @@ if(CMAKE_TOOLCHAIN_FILE)
   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 ()
@@ -66,9 +81,7 @@ 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)
@@ -80,102 +93,70 @@ endif ()
 include(RippledCompiler)
 include(RippledInterface)
 
-###
-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)
+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)
+include(deps/WasmEdge) 
+  if(TARGET nudb::core)
+  set(nudb nudb::core)
+elseif(TARGET NuDB::nudb)
+  set(nudb NuDB::nudb)
 else()
-  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})
+  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()
+if(reporting)
+  find_package(cassandra-cpp-driver REQUIRED)
+  find_package(PostgreSQL REQUIRED)
   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
+    cassandra-cpp-driver::cassandra-cpp-driver
+    PostgreSQL::PostgreSQL
   )
 endif()
-
-if(coverage)
-  include(RippledCov)
-endif()
+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
+)
 
 ###
 
 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,25 +123,6 @@ 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.
@@ -195,9 +176,10 @@ existing maintainer without a vote.
 
 ## Current Maintainers
 
-* [Richard Holland](https://github.com/RichardAH) (XRPL Labs + XRP Ledger Foundation)
-* [Denis Angell](https://github.com/dangell7) (XRPL Labs + XRP Ledger Foundation)
-* [Wietse Wind](https://github.com/WietseWind) (XRPL Labs + XRP Ledger Foundation)
+* [Richard Holland](https://github.com/RichardAH) (XRPL Labs + INFTF)
+* [Denis Angell](https://github.com/dangell7) (XRPL Labs + INFTF)
+* [Wietse Wind](https://github.com/WietseWind) (XRPL Labs + INFTF)
+* [tequ](https://github.com/tequdev) (Independent + INFTF)
 
 
 [1]: https://docs.github.com/en/get-started/quickstart/contributing-to-projects

README.md

@@ -2,7 +2,7 @@
 
 **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.
 
-[Xahau](https://xahau.network/) is a decentralized cryptographic ledger that builds upon the robust foundation of the XRP Ledger. It inherits the XRP Ledger's Byzantine Fault Tolerant consensus algorithm and enhances it with additional features and functionalities. Developers and users familiar with the XRP Ledger will find that most documentation and tutorials available on [xrpl.org](https://xrpl.org) are relevant and applicable to Xahau, including those related to running validators and managing validator keys. For Xahau specific documentation you can visit our [documentation](https://docs.xahau.network/)
+[Xahau](https://xahau.network/) is a decentralized cryptographic ledger that builds upon the robust foundation of the XRP Ledger. It inherits the XRP Ledger's Byzantine Fault Tolerant consensus algorithm and enhances it with additional features and functionalities. Developers and users familiar with the XRP Ledger will find that most documentation and tutorials available on [xrpl.org](https://xrpl.org) are relevant and applicable to Xahau, including those related to running validators and managing validator keys. For Xahau specific documentation you can visit our [documentation](https://xahau.network/)
 
 ## XAH
 XAH is the public, counterparty-free asset native to Xahau and functions primarily as network gas. Transactions submitted to the Xahau network must supply an appropriate amount of XAH, to be burnt by the network as a fee, in order to be successfully included in a validated ledger. In addition, XAH also acts as a bridge currency within the Xahau DEX. XAH is traded on the open-market and is available for anyone to access. Xahau was created in 2023 with a supply of 600 million units of XAH.
@@ -12,7 +12,7 @@ The server software that powers Xahau is called `xahaud` and is available in thi
 
 ### Build from Source
 
-* [Read the build instructions in our documentation](https://docs.xahau.network/infrastructure/building-xahau)
+* [Read the build instructions in our documentation](https://xahau.network/infrastructure/building-xahau)
 * If you encounter any issues, please [open an issue](https://github.com/xahau/xahaud/issues)
 
 ## Highlights of Xahau
@@ -58,7 +58,7 @@ git-subtree. See those directories' README files for more details.
 
 - **Documentation**: Documentation for XRPL, Xahau and Hooks.
   - [Xrpl Documentation](https://xrpl.org)
-  - [Xahau Documentation](https://docs.xahau.network/)
+  - [Xahau Documentation](https://xahau.network/)
   - [Hooks Technical Documentation](https://xrpl-hooks.readme.io/)
 - **Explorers**: Explore the Xahau ledger using various explorers:
   - [xahauexplorer.com](https://xahauexplorer.com)

RELEASENOTES.md

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

build-core.sh

@@ -5,8 +5,6 @@
 # debugging.
 set -ex
 
-set -e
-
 echo "START INSIDE CONTAINER - CORE"
 
 echo "-- BUILD CORES:       $3"
@@ -14,6 +12,13 @@ echo "-- GITHUB_REPOSITORY: $1"
 echo "-- GITHUB_SHA:        $2"
 echo "-- GITHUB_RUN_NUMBER: $4"
 
+# Use mounted filesystem for temp files to avoid container space limits
+export TMPDIR=/io/tmp
+export TEMP=/io/tmp
+export TMP=/io/tmp
+mkdir -p /io/tmp
+echo "=== Using temp directory: /io/tmp ==="
+
 umask 0000;
 
 cd /io/ &&
@@ -27,7 +32,8 @@ if [[ "$?" -ne "0" ]]; then
   exit 127
 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 &&
+BUILD_TYPE=Release
+
 mv Builds/CMake/deps/WasmEdge.cmake Builds/CMake/deps/WasmEdge.old &&
 echo "find_package(LLVM REQUIRED CONFIG)
 message(STATUS \"Found LLVM \${LLVM_PACKAGE_VERSION}\")
@@ -38,13 +44,40 @@ target_link_libraries (ripple_libs INTERFACE wasmedge)
 add_library (wasmedge::wasmedge ALIAS wasmedge)
 message(\"WasmEdge DONE\")
 " > Builds/CMake/deps/WasmEdge.cmake &&
+
+export LDFLAGS="-static-libstdc++"
+
+git config --global --add safe.directory /io &&
 git checkout src/ripple/protocol/impl/BuildInfo.cpp &&
-sed -i s/\"0.0.0\"/\"$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4\"/g src/ripple/protocol/impl/BuildInfo.cpp &&
+sed -i s/\"0.0.0\"/\"$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)$(if [ -n "$4" ]; then echo "+$4"; fi)\"/g src/ripple/protocol/impl/BuildInfo.cpp &&
+conan export external/snappy --version 1.1.10 --user xahaud --channel stable &&
+conan export external/soci --version 4.0.3 --user xahaud --channel stable &&
+conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable &&
 cd release-build &&
-cmake .. -DCMAKE_BUILD_TYPE=Release -DBoost_NO_BOOST_CMAKE=ON -DLLVM_DIR=/usr/lib64/llvm13/lib/cmake/llvm/ -DLLVM_LIBRARY_DIR=/usr/lib64/llvm13/lib/ -DWasmEdge_LIB=/usr/local/lib64/libwasmedge.a &&
-make -j$3 VERBOSE=1 &&
+# Install dependencies - tool_requires in conanfile.py handles glibc 2.28 compatibility
+# for build tools (protoc, grpc plugins, b2) in HBB environment
+# The tool_requires('b2/5.3.2') in conanfile.py should force b2 to build from source
+# with the correct toolchain, avoiding the GLIBCXX_3.4.29 issue
+echo "=== Installing dependencies ===" &&
+conan install .. --output-folder . --build missing --settings build_type=$BUILD_TYPE \
+  -o with_wasmedge=False -o tool_requires_b2=True &&
+cmake .. -G Ninja \
+  -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
+  -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+  -DCMAKE_EXE_LINKER_FLAGS="-static-libstdc++" \
+  -DLLVM_DIR=$LLVM_DIR \
+  -DWasmEdge_LIB=$WasmEdge_LIB \
+  -Dxrpld=TRUE \
+  -Dtests=TRUE &&
+ccache -z &&
+ninja -j $3 && echo "=== Re-running final link with verbose output ===" && rm -f rippled && ninja -v rippled &&
+ccache -s &&
 strip -s rippled &&
 mv rippled xahaud &&
+echo "=== Full ldd output ===" &&
+ldd xahaud &&
+echo "=== Running libcheck ===" &&
+libcheck xahaud &&
 echo "Build host: `hostname`" > release.info &&
 echo "Build date: `date`" >> release.info &&
 echo "Build md5: `md5sum xahaud`" >> release.info &&
@@ -69,8 +102,8 @@ fi
 cd ..;
 
 mv src/ripple/net/impl/RegisterSSLCerts.cpp.old src/ripple/net/impl/RegisterSSLCerts.cpp;
-mv Builds/CMake/deps/Rocksdb.cmake.old Builds/CMake/deps/Rocksdb.cmake;
 mv Builds/CMake/deps/WasmEdge.old Builds/CMake/deps/WasmEdge.cmake;
-
+rm src/certs/certbundle.h;
+git checkout src/ripple/protocol/impl/BuildInfo.cpp;
 
 echo "END INSIDE CONTAINER - CORE"

build-full.sh

@@ -3,8 +3,6 @@
 # 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"
@@ -16,13 +14,6 @@ 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;
@@ -73,92 +64,15 @@ 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 -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++ \
-  devtoolset-9-gcc-c++ \
-  devtoolset-10-gcc-c++ \
-  snappy snappy-devel \
-  zlib zlib-devel \
-  lz4-devel \
-  libasan &&
-export PATH=`echo $PATH | sed -E "s/devtoolset-9/devtoolset-7/g"` &&
-echo "-- Install ZStd 1.1.3 --" &&
-yum install epel-release -y &&
-ZSTD_VERSION="1.1.3" &&
-( wget -nc -q -O zstd-${ZSTD_VERSION}.tar.gz https://github.com/facebook/zstd/archive/v${ZSTD_VERSION}.tar.gz; echo "" ) &&
-tar xzvf zstd-${ZSTD_VERSION}.tar.gz &&
-cd zstd-${ZSTD_VERSION} &&
-make -j$3 install &&
-cd .. &&
-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.86.0 --" &&
-pwd &&
-( 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 &&
-( wget -nc -q https://github.com/protocolbuffers/protobuf/releases/download/v3.20.0/protobuf-all-3.20.0.tar.gz; echo "" ) &&
-tar -xzf protobuf-all-3.20.0.tar.gz &&
-cd protobuf-3.20.0/ &&
-./autogen.sh && ./configure --prefix=/usr --disable-shared link=static && make -j$3 && make install &&
-cd .. &&
-echo "-- Build LLD --" &&
-pwd &&
-ln /usr/bin/llvm-config-13 /usr/bin/llvm-config &&
-mv /opt/rh/devtoolset-9/root/usr/bin/ar /opt/rh/devtoolset-9/root/usr/bin/ar-9 &&
-ln /opt/rh/devtoolset-10/root/usr/bin/ar  /opt/rh/devtoolset-9/root/usr/bin/ar &&
-( wget -nc -q https://github.com/llvm/llvm-project/releases/download/llvmorg-13.0.1/lld-13.0.1.src.tar.xz; echo "" ) &&
-( wget -nc -q https://github.com/llvm/llvm-project/releases/download/llvmorg-13.0.1/libunwind-13.0.1.src.tar.xz; echo "" ) &&
-tar -xf lld-13.0.1.src.tar.xz &&
-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 -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 &&
-ln -s /usr/lib64/llvm13/lib/include/lld /usr/include/lld &&
-cp /usr/lib64/llvm13/lib/liblld*.a /usr/local/lib/ &&
-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 -p build; echo "" ) &&
-cd build &&
-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_86_0" &&
-export PATH=`echo $PATH | sed -E "s/devtoolset-7/devtoolset-9/g"` &&
-cmake .. \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DWASMEDGE_BUILD_SHARED_LIB=OFF \
-    -DWASMEDGE_BUILD_STATIC_LIB=ON \
-    -DWASMEDGE_BUILD_AOT_RUNTIME=ON \
-    -DWASMEDGE_FORCE_DISABLE_LTO=ON \
-    -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
-    -DWASMEDGE_LINK_LLVM_STATIC=ON \
-    -DWASMEDGE_BUILD_PLUGINS=OFF \
-    -DWASMEDGE_LINK_TOOLS_STATIC=ON \
-    -DBoost_NO_BOOST_CMAKE=ON -DLLVM_DIR=/usr/lib64/llvm13/lib/cmake/llvm/ -DLLVM_LIBRARY_DIR=/usr/lib64/llvm13/lib/ &&
-make -j$3 install &&
-export PATH=`echo $PATH | sed -E "s/devtoolset-9/devtoolset-10/g"` &&
-cp -r include/api/wasmedge /usr/include/ &&
-cd /io/ &&
+# Environment setup moved to Dockerfile in release-builder.sh
+source /opt/rh/gcc-toolset-11/enable
+export PATH=/usr/local/bin:$PATH
+export CC='ccache gcc' &&
+export CXX='ccache g++' &&
 echo "-- Build Rippled --" &&
 pwd &&
-cp Builds/CMake/deps/Rocksdb.cmake Builds/CMake/deps/Rocksdb.cmake.old &&
 
-echo "MOVING TO [ build-core.sh ]"
-cd /io;
+echo "MOVING TO [ build-core.sh ]";
 
 printenv > .env.temp;
 cat .env.temp | grep '=' | sed s/\\\(^[^=]\\+=\\\)/\\1\\\"/g|sed s/\$/\\\"/g > .env;

cfg/validators-example.txt

@@ -1,7 +1,7 @@
 #
 # Default validators.txt
 #
-# This file is located in the same folder as your rippled.cfg file
+# This file is located in the same folder as your xahaud.cfg file
 # and defines which validators your server trusts not to collude.
 #
 # This file is UTF-8 with DOS, UNIX, or Mac style line endings.
@@ -17,18 +17,17 @@
 #   See validator_list_sites and validator_list_keys below.
 #
 #   Examples:
-#    n9KorY8QtTdRx7TVDpwnG9NvyxsDwHUKUEeDLY3AkiGncVaSXZi5
-#    n9MqiExBcoG19UXwoLjBJnhsxEhAZMuWwJDRdkyDz1EkEkwzQTNt
+#    n9L3GdotB8a3AqtsvS7NXt4BUTQSAYyJUr9xtFj2qXJjfbZsawKY
+#    n9M7G6eLwQtUjfCthWUmTN8L4oEZn1sNr46yvKrpsq58K1C6LAxz
 #
 # [validator_list_sites]
 #
 #   List of URIs serving lists of recommended validators.
 #
 #   Examples:
-#    https://vl.ripple.com
-#    https://vl.xrplf.org
+#    https://vl.xahau.org
 #    http://127.0.0.1:8000
-#    file:///etc/opt/ripple/vl.txt
+#    file:///etc/opt/xahaud/vl.txt
 #
 # [validator_list_keys]
 #
@@ -39,50 +38,48 @@
 #   Validator list keys should be hex-encoded.
 #
 #   Examples:
-#    ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
-#    ED307A760EE34F2D0CAA103377B1969117C38B8AA0AA1E2A24DAC1F32FC97087ED
+#    EDA46E9C39B1389894E690E58914DC1029602870370A0993E5B87C4A24EAF4A8E8
 #
 # [import_vl_keys]
 #
 #   This section is used to import the public keys of trusted validator list publishers.
 #   The keys are used to authenticate and accept new lists of trusted validators.
-#   In this example, the key for the publisher "vl.xrplf.org" is imported.
 #   Each key is represented as a hexadecimal string.
 # 
 #   Examples:
-#    ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
+#	 ED45D1840EE724BE327ABE9146503D5848EFD5F38B6D5FEDE71E80ACCE5E6E738B
+#	 ED42AEC58B701EEBB77356FFFEC26F83C1F0407263530F068C7C73D392C7E06FD1
+#	 ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
 
-# The default validator list publishers that the rippled instance
+# The default validator list publishers that the xahaud instance
 # trusts.
 #
-# WARNING: Changing these values can cause your rippled instance to see a
-#          validated ledger that contradicts other rippled instances'
+# WARNING: Changing these values can cause your xahaud instance to see a
+#          validated ledger that contradicts other xahaud instances'
 #          validated ledgers (aka a ledger fork) if your validator list(s)
 #          do not sufficiently overlap with the list(s) used by others.
 #          See: https://arxiv.org/pdf/1802.07242.pdf
 
 [validator_list_sites]
-https://vl.ripple.com
-https://vl.xrplf.org
+https://vl.xahau.org
 
 [validator_list_keys]
-#vl.ripple.com
-ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
-# vl.xrplf.org
-ED45D1840EE724BE327ABE9146503D5848EFD5F38B6D5FEDE71E80ACCE5E6E738B
+# vl.xahau.org
+EDA46E9C39B1389894E690E58914DC1029602870370A0993E5B87C4A24EAF4A8E8
 
 [import_vl_keys]
-# vl.xrplf.org
+ED45D1840EE724BE327ABE9146503D5848EFD5F38B6D5FEDE71E80ACCE5E6E738B
+ED42AEC58B701EEBB77356FFFEC26F83C1F0407263530F068C7C73D392C7E06FD1
 ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
 
-# To use the test network (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
+# To use the test network (see https://xahau.network/docs/infrastructure/installing-xahaud),
 # use the following configuration instead:
 #
-# [validator_list_sites]
-# https://vl.altnet.rippletest.net
-#
-# [validator_list_keys]
-# ED264807102805220DA0F312E71FC2C69E1552C9C5790F6C25E3729DEB573D5860
+# [validators]
+# nHBoJCE3wPgkTcrNPMHyTJFQ2t77EyCAqcBRspFCpL6JhwCm94VZ
+# nHUVv4g47bFMySAZFUKVaXUYEmfiUExSoY4FzwXULNwJRzju4XnQ
+# nHBvr8avSFTz4TFxZvvi4rEJZZtyqE3J6KAAcVWVtifsE7edPM7q
+# nHUH3Z8TRU57zetHbEPr1ynyrJhxQCwrJvNjr4j1SMjYADyW1WWe
 #
 # [import_vl_keys]
 # ED264807102805220DA0F312E71FC2C69E1552C9C5790F6C25E3729DEB573D5860

cfg/xahaud-example.cfg

@@ -9,7 +9,7 @@
 #
 #   2. Peer Protocol
 #
-#   3. Ripple Protocol
+#   3. XRPL Protocol
 #
 #   4. HTTPS Client
 #
@@ -29,18 +29,17 @@
 #
 # Purpose
 #
-#   This file documents and provides examples of all rippled server process
-#   configuration options. When the rippled server instance is launched, it
+#   This file documents and provides examples of all xahaud server process
+#   configuration options. When the xahaud server instance is launched, it
 #   looks for a file with the following name:
 #
-#     rippled.cfg
+#     xahaud.cfg
 #
-#   For more information on where the rippled server instance searches for the
-#   file, visit:
+#   To run xahaud with a custom configuration file, use the "--conf {file}" flag.
+#   By default, xahaud will look in the local working directory or the home directory.
 #
-#     https://xrpl.org/commandline-usage.html#generic-options
 #
-#   This file should be named rippled.cfg. This file is UTF-8 with DOS, UNIX,
+#   This file should be named xahaud.cfg. This file is UTF-8 with DOS, UNIX,
 #   or Mac style end of lines. Blank lines and lines beginning with '#' are
 #   ignored. Undefined sections are reserved. No escapes are currently defined.
 #
@@ -89,8 +88,8 @@
 #
 #
 #
-#   rippled offers various server protocols to clients making inbound
-#   connections. The listening ports rippled uses are "universal" ports
+#   xahaud offers various server protocols to clients making inbound
+#   connections. The listening ports xahaud uses are "universal" ports
 #   which may be configured to handshake in one or more of the available
 #   supported protocols. These universal ports simplify administration:
 #   A single open port can be used for multiple protocols.
@@ -103,7 +102,7 @@
 #
 #   A list of port names and key/value pairs. A port name must start with a
 #   letter and contain only letters and numbers. The name is not case-sensitive.
-#   For each name in this list, rippled will look for a configuration file
+#   For each name in this list, xahaud will look for a configuration file
 #   section with the same name and use it to create a listening port. The
 #   name is informational only; the choice of name does not affect the function
 #   of the listening port.
@@ -134,7 +133,7 @@
 #       ip = 127.0.0.1
 #       protocol = http
 #
-#   When rippled is used as a command line client (for example, issuing a
+#   When xahaud is used as a command line client (for example, issuing a
 #   server stop command), the first port advertising the http or https
 #   protocol will be used to make the connection.
 #
@@ -175,7 +174,7 @@
 #       same time. It is possible have both Websockets and Secure Websockets
 #       together in one port.
 #
-#       NOTE    If no ports support the peer protocol, rippled cannot
+#       NOTE    If no ports support the peer protocol, xahaud cannot
 #               receive incoming peer connections or become a superpeer.
 #
 #   limit = <number>
@@ -194,7 +193,7 @@
 #       required. IP address restrictions, if any, will be checked in addition
 #       to the credentials specified here.
 #
-#       When acting in the client role, rippled will supply these credentials
+#       When acting in the client role, xahaud will supply these credentials
 #       using HTTP's Basic Authentication headers when making outbound HTTP/S
 #       requests.
 #
@@ -237,7 +236,7 @@
 #       WS, or WSS protocol interfaces. If administrative commands are
 #       disabled for a port, these credentials have no effect.
 #
-#       When acting in the client role, rippled will supply these credentials
+#       When acting in the client role, xahaud will supply these credentials
 #       in the submitted JSON for any administrative command requests when
 #       invoking JSON-RPC commands on remote servers.
 #
@@ -258,7 +257,7 @@
 #       resource controls will default to those for non-administrative users.
 #
 #       The secure_gateway IP addresses are intended to represent
-#       proxies. Since rippled trusts these hosts, they must be
+#       proxies. Since xahaud trusts these hosts, they must be
 #       responsible for properly authenticating the remote user.
 #
 #       If some IP addresses are included for both "admin" and
@@ -272,7 +271,7 @@
 #       Use the specified files when configuring SSL on the port.
 #
 #       NOTE    If no files are specified and secure protocols are selected,
-#               rippled will generate an internal self-signed certificate.
+#               xahaud will generate an internal self-signed certificate.
 #
 #       The files have these meanings:
 #
@@ -283,26 +282,24 @@
 #       ssl_cert
 #
 #           Specifies the path to the SSL certificate file in PEM format.
-#           This is not needed if the chain includes it. Use ssl_chain if
-#           your certificate includes one or more intermediates.
+#           This is not needed if the chain includes it.
 #
 #       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>
 #
 #       Control the ciphers which the server will support over SSL on the port,
 #       specified using the OpenSSL "cipher list format".
 #
-#       NOTE    If unspecified, rippled will automatically configure a modern
+#       NOTE    If unspecified, xahaud will automatically configure a modern
 #               cipher suite. This default suite should be widely supported.
 #
 #               You should not modify this string unless you have a specific
 #               reason and cryptographic expertise. Incorrect modification may
-#               keep rippled from connecting to other instances of rippled or
+#               keep xahaud from connecting to other instances of xahaud or
 #               prevent RPC and WebSocket clients from connecting.
 #
 #   send_queue_limit = [1..65535]
@@ -353,7 +350,7 @@
 #
 #   Examples:
 #     { "command" : "server_info" }
-#     { "command" : "log_level", "partition" : "ripplecalc", "severity" : "trace" }
+#     { "command" : "log_level", "partition" : "xahaudcalc", "severity" : "trace" }
 #
 #
 #
@@ -382,31 +379,15 @@
 #-----------------
 #
 #   These settings control security and access attributes of the Peer to Peer
-#   server section of the rippled process. Peer Protocol implements the
-#   Ripple Payment protocol. It is over peer connections that transactions
-#   and validations are passed from to machine to machine, to determine the
-#   contents of validated ledgers.
-#
-#
-#
-# [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
+#   server section of the xahaud process. It is over peer connections that 
+#   transactions and validations are passed from to machine to machine, to 
+#   determine the contents of validated ledgers.
 #
 #
 #
 # [ips]
 #
-#   List of hostnames or ips where the Ripple protocol is served.  A default
+#   List of hostnames or ips where the XRPL protocol is served.  A default
 #   starter list is included in the code and used if no other hostnames are
 #   available.
 #
@@ -415,24 +396,23 @@
 #   does not generally matter.
 #
 #   The default list of entries is:
-#     - r.ripple.com 51235
-#     - zaphod.alloy.ee 51235
-#     - sahyadri.isrdc.in 51235
+#     - hubs.xahau.as16089.net 21337
+#     - bacab.alloy.ee 21337
 #
 #   Examples:
 #
 #   [ips]
 #   192.168.0.1
-#   192.168.0.1 2459
-#   r.ripple.com 51235
+#   192.168.0.1 21337
+#   bacab.alloy.ee 21337
 #
 #
 # [ips_fixed]
 #
-#   List of IP addresses or hostnames to which rippled should always attempt to
+#   List of IP addresses or hostnames to which xahaud should always attempt to
 #   maintain peer connections with. This is useful for manually forming private
 #   networks, for example to configure a validation server that connects to the
-#   Ripple network through a public-facing server, or for building a set
+#   Xahau Network through a public-facing server, or for building a set
 #   of cluster peers.
 #
 #   One address or domain names per line is allowed. A port must be specified
@@ -478,6 +458,19 @@
 #
 #
 #
+# [sntp_servers]
+#
+#   IP address or domain of NTP servers to use for time synchronization.
+#
+#   These NTP servers are suitable for xahaud 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
@@ -570,7 +563,7 @@
 #
 #   minimum_txn_in_ledger_standalone = <number>
 #
-#       Like minimum_txn_in_ledger when rippled is running in standalone
+#       Like minimum_txn_in_ledger when xahaud is running in standalone
 #       mode. Default: 1000.
 #
 #   target_txn_in_ledger = <number>
@@ -707,7 +700,7 @@
 #
 # [validator_token]
 #
-#   This is an alternative to [validation_seed] that allows rippled to perform
+#   This is an alternative to [validation_seed] that allows xahaud to perform
 #   validation without having to store the validator keys on the network
 #   connected server. The field should contain a single token in the form of a
 #   base64-encoded blob.
@@ -742,19 +735,18 @@
 #
 #   Specify the file by its name or path.
 #   Unless an absolute path is specified, it will be considered relative to
-#   the folder in which the rippled.cfg file is located.
+#   the folder in which the xahaud.cfg file is located.
 #
 #   Examples:
-#    /home/ripple/validators.txt
-#    C:/home/ripple/validators.txt
+#    /home/xahaud/validators.txt
+#    C:/home/xahaud/validators.txt
 #
 #   Example content:
 #    [validators]
-#    n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7
-#    n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj
-#    n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C
-#    n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS
-#    n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA
+#    n9L3GdotB8a3AqtsvS7NXt4BUTQSAYyJUr9xtFj2qXJjfbZsawKY
+#    n9LQDHLWyFuAn5BXJuW2ow5J9uGqpmSjRYS2cFRpxf6uJbxwDzvM
+#    n9MCWyKVUkiatXVJTKUrAESB5kBFP8R3hm43jGHtg8WBnjv3iDfb
+#    n9KWXCLRhjpajuZtULTXsy6R5xbisA6ozGxM4zdEJFq6uHiFZDvW
 #
 #
 #
@@ -837,7 +829,7 @@
 #
 #   0: Disable the ledger replay feature [default]
 #   1: Enable the ledger replay feature. With this feature enabled, when
-#      acquiring a ledger from the network, a rippled node only downloads
+#      acquiring a ledger from the network, a xahaud node only downloads
 #      the ledger header and the transactions instead of the whole ledger.
 #      And the ledger is built by applying the transactions to the parent
 #      ledger.
@@ -848,10 +840,9 @@
 #
 #----------------
 #
-#   The rippled server instance uses HTTPS GET requests in a variety of
+#   The xahaud server instance uses HTTPS GET requests in a variety of
 #   circumstances, including but not limited to contacting trusted domains to
-#   fetch information such as mapping an email address to a Ripple Payment
-#   Network address.
+#   fetch information such as mapping an email address to a user's r address.
 #
 # [ssl_verify]
 #
@@ -888,15 +879,15 @@
 #
 #------------
 #
-#   rippled has an optional operating mode called Reporting Mode. In Reporting
-#   Mode, rippled does not connect to the peer to peer network. Instead, rippled
-#   will continuously extract data from one or more rippled servers that are
+#   xahaud has an optional operating mode called Reporting Mode. In Reporting
+#   Mode, xahaud does not connect to the peer to peer network. Instead, xahaud 
+#   will continuously extract data from one or more xahaud servers that are
 #   connected to the peer to peer network (referred to as an ETL source).
 #   Reporting mode servers will forward RPC requests that require access to the
 #   peer to peer network (submit, fee, etc) to an ETL source.
 #
 #   [reporting]  Settings for Reporting Mode. If and only if this section is
-#                present, rippled will start in reporting mode. This section
+#                present, xahaud will start in reporting mode. This section
 #                contains a list of ETL source names, and key-value pairs. The
 #                ETL source names each correspond to a configuration file
 #                section; the names must match exactly. The key-value pairs are
@@ -1001,16 +992,16 @@
 #
 #------------
 #
-#   rippled creates 4 SQLite database to hold bookkeeping information
+#   xahaud creates 4 SQLite database to hold bookkeeping information
 #   about transactions, local credentials, and various other things.
 #   It also creates the NodeDB, which holds all the objects that
-#   make up the current and historical ledgers. In Reporting Mode, rippled
+#   make up the current and historical ledgers. In Reporting Mode, xahauad 
 #   uses a Postgres database instead of SQLite.
 #
 #   The simplest way to work with Postgres is to install it locally.
 #   When it is running, execute the initdb.sh script in the current
 #   directory as: sudo -u postgres ./initdb.sh
-#   This will create the rippled user and an empty database of the same name.
+#   This will create the xahaud user and an empty database of the same name.
 #
 #   The size of the NodeDB grows in proportion to the amount of new data and the
 #   amount of historical data (a configurable setting) so the performance of the
@@ -1018,7 +1009,7 @@
 #   the performance of the server.
 #
 #   Partial pathnames will be considered relative to the location of
-#   the rippled.cfg file.
+#   the xahaud.cfg file.
 #
 #   [node_db]               Settings for the Node Database (required)
 #
@@ -1029,18 +1020,18 @@
 #
 #   Example:
 #       type=nudb
-#       path=db/nudb
+#       path=/opt/xahaud/db/nudb
 #
 #   The "type" field must be present and controls the choice of backend:
 #
 #   type = NuDB
 #
 #       NuDB is a high-performance database written by Ripple Labs and optimized
-#       for rippled and solid-state drives.
+#       for and solid-state drives.
 #
 #       NuDB maintains its high speed regardless of the amount of history
 #       stored. Online delete may be selected, but is not required. NuDB is
-#       available on all platforms that rippled runs on.
+#       available on all platforms that xahaud runs on.
 #
 #   type = RocksDB
 #
@@ -1067,14 +1058,16 @@
 #       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:
+#   Required keys for NuDB and RocksDB:
 #
 #       path                Location to store the database
 #
+#   Required keys for RWDB:
+#
+#       online_delete       Required. RWDB stores data in memory and will
+#                           grow unbounded without online_delete. See the
+#                           online_delete section below.
+#
 #   Required keys for Cassandra:
 #
 #      contact_points       IP of a node in the Cassandra cluster
@@ -1114,9 +1107,19 @@
 #                           if sufficient IOPS capacity is available.
 #                           Default 0.
 #
-#   Optional keys for NuDB or RocksDB:
+#   online_delete for RWDB, NuDB and RocksDB:
 #
-#       earliest_seq        The default is 32570 to match the XRP ledger
+#       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.
+#
+#                           REQUIRED for RWDB to prevent out-of-memory errors.
+#                           Optional for NuDB and RocksDB.
+#
+#   Optional keys for NuDB and RocksDB:
+#
+#       earliest_seq        The default is 32570 to match the XRP Ledger's
 #                           network's earliest allowed sequence. Alternate
 #                           networks may set this value. Minimum value of 1.
 #                           If a [shard_db] section is defined, and this
@@ -1124,12 +1127,40 @@
 #                           it must be defined with the same value in both
 #                           sections.
 #
-#       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. If using RWDB 
-#                           this value is ignored.
+#   Optional keys for NuDB only:
 #
+#       nudb_block_size     EXPERIMENTAL: Block size in bytes for NuDB storage.
+#                           Must be a power of 2 between 4096 and 32768. Default is 4096.
+#
+#                           This parameter controls the fundamental storage unit
+#                           size for NuDB's internal data structures. The choice
+#                           of block size can significantly impact performance
+#                           depending on your storage hardware and filesystem:
+#
+#                           - 4096 bytes: Optimal for most standard SSDs and
+#                             traditional filesystems (ext4, NTFS, HFS+).
+#                             Provides good balance of performance and storage
+#                             efficiency. Recommended for most deployments.
+#
+#                           - 8192-16384 bytes: May improve performance on
+#                             high-end NVMe SSDs and copy-on-write filesystems
+#                             like ZFS or Btrfs that benefit from larger block
+#                             alignment. Can reduce metadata overhead for large
+#                             databases.
+#
+#                           - 32768 bytes (32K): Maximum supported block size
+#                             for high-performance scenarios with very fast
+#                             storage. May increase memory usage and reduce
+#                             efficiency for smaller databases.
+#
+#                           Note: This setting cannot be changed after database
+#                           creation without rebuilding the entire database.
+#                           Choose carefully based on your hardware and expected
+#                           database size.
+#
+#                           Example: nudb_block_size=4096
+#
+
 #       These keys modify the behavior of online_delete, and thus are only
 #       relevant if online_delete is defined and non-zero:
 #
@@ -1163,7 +1194,7 @@
 #
 #       recovery_wait_seconds
 #                           The online delete process checks periodically
-#                           that rippled is still in sync with the network,
+#                           that xahaud is still in sync with the network,
 #                           and that the validated ledger is less than
 #                           'age_threshold_seconds' old. If not, then continue
 #                           sleeping for this number of seconds and 
@@ -1202,8 +1233,8 @@
 #   The server creates and maintains 4 to 5 bookkeeping SQLite databases in
 #   the 'database_path' location. If you omit this configuration setting,
 #   the server creates a directory called "db" located in the same place as
-#   your rippled.cfg file.
-#   Partial pathnames are relative to the location of the rippled executable.
+#   your xahaud.cfg file.
+#   Partial pathnames are relative to the location of the xahaud executable.
 #
 #   [shard_db]      Settings for the Shard Database (optional)
 #
@@ -1279,7 +1310,7 @@
 #                           The default is "wal", which uses a write-ahead
 #                           log to implement database transactions.
 #                           Alternately, "memory" saves disk I/O, but if
-#                           rippled crashes during a transaction, the
+#                           xahaud crashes during a transaction, the
 #                           database is likely to be corrupted.
 #                           See https://www.sqlite.org/pragma.html#pragma_journal_mode
 #                           for more details about the available options.
@@ -1289,7 +1320,7 @@
 #       synchronous         Valid values: off, normal, full, extra
 #                           The default is "normal", which works well with
 #                           the "wal" journal mode. Alternatively, "off"
-#                           allows rippled to continue as soon as data is
+#                           allows xahaud to continue as soon as data is
 #                           passed to the OS, which can significantly
 #                           increase speed, but risks data corruption if
 #                           the host computer crashes before writing that
@@ -1303,7 +1334,7 @@
 #                           The default is "file", which will use files
 #                           for temporary database tables and indices.
 #                           Alternatively, "memory" may save I/O, but
-#                           rippled does not currently use many, if any,
+#                           xahaud does not currently use many, if any,
 #                           of these temporary objects.
 #                           See https://www.sqlite.org/pragma.html#pragma_temp_store
 #                           for more details about the available options.
@@ -1315,9 +1346,9 @@
 #      conninfo             Info for connecting to Postgres. Format is
 #                           postgres://[username]:[password]@[ip]/[database].
 #                           The database and user must already exist. If this
-#                           section is missing and rippled is running in
-#                           Reporting Mode, rippled will connect as the
-#                           user running rippled to a database with the
+#                           section is missing and xahaud is running in
+#                           Reporting Mode, xahaud will connect as the
+#                           user running xahaud to a database with the
 #                           same name. On Linux and Mac OS X, the connection
 #                           will take place using the server's UNIX domain
 #                           socket. On Windows, through the localhost IP
@@ -1326,7 +1357,7 @@
 #      use_tx_tables        Valid values: 1, 0
 #                           The default is 1 (true). Determines whether to use
 #                           the SQLite transaction database. If set to 0,
-#                           rippled will not write to the transaction database,
+#                           xahaud will not write to the transaction database,
 #                           and will reject tx, account_tx and tx_history RPCs.
 #                           In Reporting Mode, this setting is ignored.
 #
@@ -1354,7 +1385,7 @@
 #
 #   These settings are designed to help server administrators diagnose
 #   problems, and obtain detailed information about the activities being
-#   performed by the rippled process.
+#   performed by the xahaud process.
 #
 #
 #
@@ -1371,7 +1402,7 @@
 #
 #   Configuration parameters for the Beast. Insight stats collection module.
 #
-#   Insight is a module that collects information from the areas of rippled
+#   Insight is a module that collects information from the areas of xahaud 
 #   that have instrumentation. The configuration parameters control where the
 #   collection metrics are sent. The parameters are expressed as key = value
 #   pairs with no white space. The main parameter is the choice of server:
@@ -1380,7 +1411,7 @@
 #
 #       Choice of server to send metrics to. Currently the only choice is
 #       "statsd" which sends UDP packets to a StatsD daemon, which must be
-#       running while rippled is running. More information on StatsD is
+#       running while xahaud is running. More information on StatsD is
 #       available here:
 #           https://github.com/b/statsd_spec
 #
@@ -1390,7 +1421,7 @@
 #                 in the format, n.n.n.n:port.
 #
 #       "prefix"  A string prepended to each collected metric. This is used
-#                 to distinguish between different running instances of rippled.
+#                 to distinguish between different running instances of xahaud.
 #
 #     If this section is missing, or the server type is unspecified or unknown,
 #     statistics are not collected or reported.
@@ -1417,7 +1448,7 @@
 #
 #   Example:
 #     [perf]
-#     perf_log=/var/log/rippled/perf.log
+#     perf_log=/var/log/xahaud/perf.log
 #     log_interval=2
 #
 #-------------------------------------------------------------------------------
@@ -1426,8 +1457,8 @@
 #
 #----------
 #
-#   The vote settings configure settings for the entire Ripple network.
-#   While a single instance of rippled cannot unilaterally enforce network-wide
+#   The vote settings configure settings for the entire Xahau Network.
+#   While a single instance of xahaud cannot unilaterally enforce network-wide
 #   settings, these choices become part of the instance's vote during the
 #   consensus process for each voting ledger.
 #
@@ -1439,9 +1470,9 @@
 #
 #       The cost of the reference transaction fee, specified in drops.
 #       The reference transaction is the simplest form of transaction.
-#       It represents an XRP payment between two parties.
+#       It represents an XAH payment between two parties.
 #
-#       If this parameter is unspecified, rippled will use an internal
+#       If this parameter is unspecified, xahaud will use an internal
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
@@ -1450,26 +1481,26 @@
 #   account_reserve = <drops>
 #
 #       The account reserve requirement is specified in drops. The portion of an
-#       account's XRP balance that is at or below the reserve may only be
+#       account's XAH balance that is at or below the reserve may only be
 #       spent on transaction fees, and not transferred out of the account.
 #
-#       If this parameter is unspecified, rippled will use an internal
+#       If this parameter is unspecified, xahaud will use an internal
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           account_reserve = 10000000   # 10 XRP
+#           account_reserve = 10000000   # 10 XAH
 #
 #   owner_reserve = <drops>
 #
-#       The owner reserve is the amount of XRP reserved in the account for
+#       The owner reserve is the amount of XAH reserved in the account for
 #       each ledger item owned by the account. Ledger items an account may
 #       own include trust lines, open orders, and tickets.
 #
-#       If this parameter is unspecified, rippled will use an internal
+#       If this parameter is unspecified, xahaud will use an internal
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           owner_reserve = 2000000      # 2 XRP
+#           owner_reserve = 2000000      # 2 XAH
 #
 #-------------------------------------------------------------------------------
 #
@@ -1507,7 +1538,7 @@
 #   tool instead.
 #
 #   This flag has no effect on the "sign" and "sign_for" command line options
-#   that rippled makes available.
+#   that xahaud makes available.
 #
 #   The default value of this field is "false"
 #
@@ -1586,7 +1617,7 @@
 #--------------------
 #
 #   Administrators can use these values as a starting point for configuring
-#   their instance of rippled, but each value should be checked to make sure
+#   their instance of xahaud, but each value should be checked to make sure
 #   it meets the business requirements for the organization.
 #
 # Server
@@ -1596,7 +1627,7 @@
 #   "peer"
 #
 #       Peer protocol open to everyone. This is required to accept
-#       incoming rippled connections. This does not affect automatic
+#       incoming xahaud connections. This does not affect automatic
 #       or manual outgoing Peer protocol connections.
 #
 #   "rpc"
@@ -1624,8 +1655,8 @@
 #   NOTE
 #
 #       To accept connections on well known ports such as 80 (HTTP) or
-#       443 (HTTPS), most operating systems will require rippled to
-#       run with administrator privileges, or else rippled will not start.
+#       443 (HTTPS), most operating systems will require xahaud to
+#       run with administrator privileges, or else xahaud will not start.
 
 [server]
 port_rpc_admin_local
@@ -1636,24 +1667,23 @@ port_ws_admin_local
 #ssl_cert = /etc/ssl/certs/server.crt
 
 [port_rpc_admin_local]
-port = 5005
+port = 5009
 ip = 127.0.0.1
 admin = 127.0.0.1
 protocol = http
 
 [port_peer]
-port = 51235
+port = 21337
 ip = 0.0.0.0
 # alternatively, to accept connections on IPv4 + IPv6, use:
 #ip = ::
 protocol = peer
 
 [port_ws_admin_local]
-port = 6006
+port = 6009
 ip = 127.0.0.1
 admin = 127.0.0.1
 protocol = ws
-send_queue_limit = 500
 
 [port_grpc]
 port = 50051
@@ -1661,16 +1691,15 @@ ip = 127.0.0.1
 secure_gateway = 127.0.0.1
 
 #[port_ws_public]
-#port = 6005
+#port = 6008
 #ip = 127.0.0.1
 #protocol = wss
-#send_queue_limit = 500
 
 #-------------------------------------------------------------------------------
 
-# This is primary persistent datastore for rippled.  This includes transaction
+# This is primary persistent datastore for xahaud.  This includes transaction
 # metadata, account states, and ledger headers.  Helpful information can be
-# found at https://xrpl.org/capacity-planning.html#node-db-type
+# found at https://xahau.network/docs/infrastructure/system-requirements
 # type=NuDB is recommended for non-validators with fast SSDs. Validators or
 #    slow / spinning disks should use RocksDB. Caution: Spinning disks are
 #    not recommended. They do not perform well enough to consistently remain
@@ -1683,16 +1712,16 @@ secure_gateway = 127.0.0.1
 #    deletion.
 [node_db]
 type=NuDB
-path=/var/lib/rippled/db/nudb
+path=/opt/xahaud/db/nudb
 online_delete=512
 advisory_delete=0
 
 # This is the persistent datastore for shards. It is important for the health
-# of the ripple network that rippled operators shard as much as practical.
+# of the Xahau Network that xahaud operators shard as much as practical.
 # NuDB requires SSD storage. Helpful information can be found at
 # https://xrpl.org/history-sharding.html
 #[shard_db]
-#path=/var/lib/rippled/db/shards/nudb
+#path=/opt/xahaud/db/shards/nudb
 #max_historical_shards=50
 #
 # This optional section can be configured with a list
@@ -1703,7 +1732,7 @@ advisory_delete=0
 #/path/2
 
 [database_path]
-/var/lib/rippled/db
+/opt/xahaud/db
 
 
 # To use Postgres, uncomment this section and fill in the appropriate connection
@@ -1718,17 +1747,27 @@ advisory_delete=0
 # This needs to be an absolute directory reference, not a relative one.
 # Modify this value as required.
 [debug_logfile]
-/var/log/rippled/debug.log
+/var/log/xahaud/debug.log
 
-# To use the XRP test network
-# (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
+[sntp_servers]
+time.windows.com
+time.apple.com
+time.nist.gov
+pool.ntp.org
+
+# To use the Xahau Test Network
+# (see https://xahau.network/docs/infrastructure/installing-xahaud),
 # use the following [ips] section:
 # [ips]
-# r.altnet.rippletest.net 51235
+# 79.110.60.121 21338
+# 79.110.60.122 21338
+# 79.110.60.124 21338
+# 79.110.60.125 21338
+
 
 # File containing trusted validator keys or validator list publishers.
 # Unless an absolute path is specified, it will be considered relative to the
-# folder in which the rippled.cfg file is located.
+# folder in which the xahaud.cfg file is located.
 [validators_file]
 validators.txt
 

cfg/xahaud-reporting.cfg

@@ -9,7 +9,7 @@
 #
 #   2. Peer Protocol
 #
-#   3. Ripple Protocol
+#   3. XRPL Protocol
 #
 #   4. HTTPS Client
 #
@@ -29,18 +29,16 @@
 #
 # Purpose
 #
-#   This file documents and provides examples of all rippled server process
-#   configuration options. When the rippled server instance is launched, it
+#   This file documents and provides examples of all xahaud server process
+#   configuration options. When the xahaud server instance is launched, it
 #   looks for a file with the following name:
 #
-#     rippled.cfg
+#     xahaud.cfg
 #
-#   For more information on where the rippled server instance searches for the
-#   file, visit:
+#   To run xahaud with a custom configuration file, use the "--conf {file}" flag.
+#   By default, xahaud will look in the local working directory or the home directory
 #
-#     https://xrpl.org/commandline-usage.html#generic-options
-#
-#   This file should be named rippled.cfg. This file is UTF-8 with DOS, UNIX,
+#   This file should be named xahaud.cfg. This file is UTF-8 with DOS, UNIX,
 #   or Mac style end of lines. Blank lines and lines beginning with '#' are
 #   ignored. Undefined sections are reserved. No escapes are currently defined.
 #
@@ -89,8 +87,8 @@
 #
 #
 #
-#   rippled offers various server protocols to clients making inbound
-#   connections. The listening ports rippled uses are "universal" ports
+#   xahaud offers various server protocols to clients making inbound
+#   connections. The listening ports xahaud uses are "universal" ports
 #   which may be configured to handshake in one or more of the available
 #   supported protocols. These universal ports simplify administration:
 #   A single open port can be used for multiple protocols.
@@ -103,7 +101,7 @@
 #
 #   A list of port names and key/value pairs. A port name must start with a
 #   letter and contain only letters and numbers. The name is not case-sensitive.
-#   For each name in this list, rippled will look for a configuration file
+#   For each name in this list, xahaud will look for a configuration file
 #   section with the same name and use it to create a listening port. The
 #   name is informational only; the choice of name does not affect the function
 #   of the listening port.
@@ -134,7 +132,7 @@
 #       ip = 127.0.0.1
 #       protocol = http
 #
-#   When rippled is used as a command line client (for example, issuing a
+#   When xahaud is used as a command line client (for example, issuing a
 #   server stop command), the first port advertising the http or https
 #   protocol will be used to make the connection.
 #
@@ -175,7 +173,7 @@
 #       same time. It is possible have both Websockets and Secure Websockets
 #       together in one port.
 #
-#       NOTE    If no ports support the peer protocol, rippled cannot
+#       NOTE    If no ports support the peer protocol, xahaud cannot
 #               receive incoming peer connections or become a superpeer.
 #
 #   limit = <number>
@@ -194,7 +192,7 @@
 #       required. IP address restrictions, if any, will be checked in addition
 #       to the credentials specified here.
 #
-#       When acting in the client role, rippled will supply these credentials
+#       When acting in the client role, xahaud will supply these credentials
 #       using HTTP's Basic Authentication headers when making outbound HTTP/S
 #       requests.
 #
@@ -227,7 +225,7 @@
 #       WS, or WSS protocol interfaces. If administrative commands are
 #       disabled for a port, these credentials have no effect.
 #
-#       When acting in the client role, rippled will supply these credentials
+#       When acting in the client role, xahaud will supply these credentials
 #       in the submitted JSON for any administrative command requests when
 #       invoking JSON-RPC commands on remote servers.
 #
@@ -247,11 +245,11 @@
 #       resource controls will default to those for non-administrative users.
 #
 #       The secure_gateway IP addresses are intended to represent
-#       proxies. Since rippled trusts these hosts, they must be
+#       proxies. Since xahaud trusts these hosts, they must be
 #       responsible for properly authenticating the remote user.
 #
 #       The same IP address cannot be used in both "admin" and "secure_gateway"
-#       lists for the same port. In this case, rippled will abort with an error
+#       lists for the same port. In this case, xahaud will abort with an error
 #       message to the console shortly after startup
 #
 #   ssl_key = <filename>
@@ -261,7 +259,7 @@
 #       Use the specified files when configuring SSL on the port.
 #
 #       NOTE    If no files are specified and secure protocols are selected,
-#               rippled will generate an internal self-signed certificate.
+#               xahaud will generate an internal self-signed certificate.
 #
 #       The files have these meanings:
 #
@@ -284,12 +282,12 @@
 #       Control the ciphers which the server will support over SSL on the port,
 #       specified using the OpenSSL "cipher list format".
 #
-#       NOTE    If unspecified, rippled will automatically configure a modern
+#       NOTE    If unspecified, xahaud will automatically configure a modern
 #               cipher suite. This default suite should be widely supported.
 #
 #               You should not modify this string unless you have a specific
 #               reason and cryptographic expertise. Incorrect modification may
-#               keep rippled from connecting to other instances of rippled or
+#               keep xahaud from connecting to other instances of xahaud or
 #               prevent RPC and WebSocket clients from connecting.
 #
 #   send_queue_limit = [1..65535]
@@ -340,7 +338,7 @@
 #
 #   Examples:
 #     { "command" : "server_info" }
-#     { "command" : "log_level", "partition" : "ripplecalc", "severity" : "trace" }
+#     { "command" : "log_level", "partition" : "xahaucalc", "severity" : "trace" }
 #
 #
 #
@@ -369,8 +367,8 @@
 #-----------------
 #
 #   These settings control security and access attributes of the Peer to Peer
-#   server section of the rippled process. Peer Protocol implements the
-#   Ripple Payment protocol. It is over peer connections that transactions
+#   server section of the xahaud process. Peer Protocol implements the
+#   XRPL Payment protocol. It is over peer connections that transactions
 #   and validations are passed from to machine to machine, to determine the
 #   contents of validated ledgers.
 #
@@ -378,7 +376,7 @@
 #
 # [ips]
 #
-#   List of hostnames or ips where the Ripple protocol is served.  A default
+#   List of hostnames or ips where the XRPL protocol is served.  A default
 #   starter list is included in the code and used if no other hostnames are
 #   available.
 #
@@ -387,24 +385,23 @@
 #   does not generally matter.
 #
 #   The default list of entries is:
-#     - r.ripple.com 51235
-#     - zaphod.alloy.ee 51235
-#     - sahyadri.isrdc.in 51235
+#     - bacab.alloy.ee 21337
+#     - hubs.xahau.as16089.net 21337
 #
 #   Examples:
 #
 #   [ips]
 #   192.168.0.1
-#   192.168.0.1 2459
-#   r.ripple.com 51235
+#   192.168.0.1 21337
+#   bacab.alloy.ee 21337
 #
 #
 # [ips_fixed]
 #
-#   List of IP addresses or hostnames to which rippled should always attempt to
+#   List of IP addresses or hostnames to which xahaud should always attempt to
 #   maintain peer connections with. This is useful for manually forming private
 #   networks, for example to configure a validation server that connects to the
-#   Ripple network through a public-facing server, or for building a set
+#   Xahau Network through a public-facing server, or for building a set
 #   of cluster peers.
 #
 #   One address or domain names per line is allowed. A port must be specified
@@ -450,6 +447,19 @@
 #
 #
 #
+# [sntp_servers]
+#
+#   IP address or domain of NTP servers to use for time synchronization.
+#
+#   These NTP servers are suitable for xahaud 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
@@ -542,7 +552,7 @@
 #
 #   minimum_txn_in_ledger_standalone = <number>
 #
-#       Like minimum_txn_in_ledger when rippled is running in standalone
+#       Like minimum_txn_in_ledger when xahaud is running in standalone
 #       mode. Default: 1000.
 #
 #   target_txn_in_ledger = <number>
@@ -669,7 +679,7 @@
 #
 # [validator_token]
 #
-#   This is an alternative to [validation_seed] that allows rippled to perform
+#   This is an alternative to [validation_seed] that allows xahaud to perform
 #   validation without having to store the validator keys on the network
 #   connected server. The field should contain a single token in the form of a
 #   base64-encoded blob.
@@ -704,22 +714,21 @@
 #
 #   Specify the file by its name or path.
 #   Unless an absolute path is specified, it will be considered relative to
-#   the folder in which the rippled.cfg file is located.
+#   the folder in which the xahaud.cfg file is located.
 #
 #   Examples:
-#    /home/ripple/validators.txt
-#    C:/home/ripple/validators.txt
+#    /home/xahaud/validators.txt
+#    C:/home/xahaud/validators.txt
 #
 #   Example content:
 #    [validators]
-#    n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7
-#    n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj
-#    n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C
-#    n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS
-#    n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA
-#
-#
-#
+#    n9L3GdotB8a3AqtsvS7NXt4BUTQSAYyJUr9xtFj2qXJjfbZsawKY
+#    n9LQDHLWyFuAn5BXJuW2ow5J9uGqpmSjRYS2cFRpxf6uJbxwDzvM
+#    n9MCWyKVUkiatXVJTKUrAESB5kBFP8R3hm43jGHtg8WBnjv3iDfb
+#    n9KWXCLRhjpajuZtULTXsy6R5xbisA6ozGxM4zdEJFq6uHiFZDvW
+
+
+
 # [path_search]
 #   When searching for paths, the default search aggressiveness. This can take
 #   exponentially more resources as the size is increased.
@@ -782,7 +791,7 @@
 #
 #   0: Disable the ledger replay feature [default]
 #   1: Enable the ledger replay feature. With this feature enabled, when
-#      acquiring a ledger from the network, a rippled node only downloads
+#      acquiring a ledger from the network, a xahaud node only downloads
 #      the ledger header and the transactions instead of the whole ledger.
 #      And the ledger is built by applying the transactions to the parent
 #      ledger.
@@ -793,9 +802,9 @@
 #
 #----------------
 #
-#   The rippled server instance uses HTTPS GET requests in a variety of
+#   The xahaud server instance uses HTTPS GET requests in a variety of
 #   circumstances, including but not limited to contacting trusted domains to
-#   fetch information such as mapping an email address to a Ripple Payment
+#   fetch information such as mapping an email address to a XRPL Payment
 #   Network address.
 #
 # [ssl_verify]
@@ -833,15 +842,15 @@
 #
 #------------
 #
-#   rippled has an optional operating mode called Reporting Mode. In Reporting
-#   Mode, rippled does not connect to the peer to peer network. Instead, rippled
-#   will continuously extract data from one or more rippled servers that are
+#   xahaud has an optional operating mode called Reporting Mode. In Reporting
+#   Mode, xahaud does not connect to the peer to peer network. Instead, xahaud
+#   will continuously extract data from one or more xahaud servers that are
 #   connected to the peer to peer network (referred to as an ETL source).
 #   Reporting mode servers will forward RPC requests that require access to the
 #   peer to peer network (submit, fee, etc) to an ETL source.
 #
 #   [reporting]  Settings for Reporting Mode. If and only if this section is
-#                present, rippled will start in reporting mode. This section
+#                present, xahaud will start in reporting mode. This section
 #                contains a list of ETL source names, and key-value pairs. The
 #                ETL source names each correspond to a configuration file
 #                section; the names must match exactly. The key-value pairs are
@@ -946,16 +955,16 @@
 #
 #------------
 #
-#   rippled creates 4 SQLite database to hold bookkeeping information
+#   xahaud creates 4 SQLite database to hold bookkeeping information
 #   about transactions, local credentials, and various other things.
 #   It also creates the NodeDB, which holds all the objects that
-#   make up the current and historical ledgers. In Reporting Mode, rippled
+#   make up the current and historical ledgers. In Reporting Mode, xahaud
 #   uses a Postgres database instead of SQLite.
 #
 #   The simplest way to work with Postgres is to install it locally.
 #   When it is running, execute the initdb.sh script in the current
 #   directory as: sudo -u postgres ./initdb.sh
-#   This will create the rippled user and an empty database of the same name.
+#   This will create the xahaud user and an empty database of the same name.
 #
 #   The size of the NodeDB grows in proportion to the amount of new data and the
 #   amount of historical data (a configurable setting) so the performance of the
@@ -963,7 +972,7 @@
 #   the performance of the server.
 #
 #   Partial pathnames will be considered relative to the location of
-#   the rippled.cfg file.
+#   the xahaud.cfg file.
 #
 #   [node_db]               Settings for the Node Database (required)
 #
@@ -981,11 +990,11 @@
 #   type = NuDB
 #
 #       NuDB is a high-performance database written by Ripple Labs and optimized
-#       for rippled and solid-state drives.
+#       for solid-state drives.
 #
 #       NuDB maintains its high speed regardless of the amount of history
 #       stored. Online delete may be selected, but is not required. NuDB is
-#       available on all platforms that rippled runs on.
+#       available on all platforms that xahaud runs on.
 #
 #   type = RocksDB
 #
@@ -1090,14 +1099,14 @@
 #
 #       recovery_wait_seconds
 #                           The online delete process checks periodically
-#                           that rippled is still in sync with the network,
+#                           that xahaud is still in sync with the network,
 #                           and that the validated ledger is less than
 #                           'age_threshold_seconds' old. By default, if it
 #                           is not the online delete process aborts and
 #                           tries again later. If 'recovery_wait_seconds'
-#                           is set and rippled is out of sync, but likely to
+#                           is set and xahaud is out of sync, but likely to
 #                           recover quickly, then online delete will wait
-#                           this number of seconds for rippled to get back
+#                           this number of seconds for xahaud to get back
 #                           into sync before it aborts.
 #                           Set this value if the node is otherwise staying
 #                           in sync, or recovering quickly, but the online
@@ -1133,8 +1142,8 @@
 #   The server creates and maintains 4 to 5 bookkeeping SQLite databases in
 #   the 'database_path' location. If you omit this configuration setting,
 #   the server creates a directory called "db" located in the same place as
-#   your rippled.cfg file.
-#   Partial pathnames are relative to the location of the rippled executable.
+#   your xahaud.cfg file.
+#   Partial pathnames are relative to the location of the xahaud executable.
 #
 #   [shard_db]      Settings for the Shard Database (optional)
 #
@@ -1210,7 +1219,7 @@
 #                           The default is "wal", which uses a write-ahead
 #                           log to implement database transactions.
 #                           Alternately, "memory" saves disk I/O, but if
-#                           rippled crashes during a transaction, the
+#                           xahaud crashes during a transaction, the
 #                           database is likely to be corrupted.
 #                           See https://www.sqlite.org/pragma.html#pragma_journal_mode
 #                           for more details about the available options.
@@ -1220,7 +1229,7 @@
 #       synchronous         Valid values: off, normal, full, extra
 #                           The default is "normal", which works well with
 #                           the "wal" journal mode. Alternatively, "off"
-#                           allows rippled to continue as soon as data is
+#                           allows xahaud to continue as soon as data is
 #                           passed to the OS, which can significantly
 #                           increase speed, but risks data corruption if
 #                           the host computer crashes before writing that
@@ -1234,7 +1243,7 @@
 #                           The default is "file", which will use files
 #                           for temporary database tables and indices.
 #                           Alternatively, "memory" may save I/O, but
-#                           rippled does not currently use many, if any,
+#                           xahaud does not currently use many, if any,
 #                           of these temporary objects.
 #                           See https://www.sqlite.org/pragma.html#pragma_temp_store
 #                           for more details about the available options.
@@ -1246,9 +1255,9 @@
 #      conninfo             Info for connecting to Postgres. Format is
 #                           postgres://[username]:[password]@[ip]/[database].
 #                           The database and user must already exist. If this
-#                           section is missing and rippled is running in
-#                           Reporting Mode, rippled will connect as the
-#                           user running rippled to a database with the
+#                           section is missing and xahaud is running in
+#                           Reporting Mode, xahaud will connect as the
+#                           user running xahaud to a database with the
 #                           same name. On Linux and Mac OS X, the connection
 #                           will take place using the server's UNIX domain
 #                           socket. On Windows, through the localhost IP
@@ -1257,7 +1266,7 @@
 #      use_tx_tables        Valid values: 1, 0
 #                           The default is 1 (true). Determines whether to use
 #                           the SQLite transaction database. If set to 0,
-#                           rippled will not write to the transaction database,
+#                           xahaud will not write to the transaction database,
 #                           and will reject tx, account_tx and tx_history RPCs.
 #                           In Reporting Mode, this setting is ignored.
 #
@@ -1285,7 +1294,7 @@
 #
 #   These settings are designed to help server administrators diagnose
 #   problems, and obtain detailed information about the activities being
-#   performed by the rippled process.
+#   performed by the xahaud process.
 #
 #
 #
@@ -1302,7 +1311,7 @@
 #
 #   Configuration parameters for the Beast. Insight stats collection module.
 #
-#   Insight is a module that collects information from the areas of rippled
+#   Insight is a module that collects information from the areas of xahaud
 #   that have instrumentation. The configuration parameters control where the
 #   collection metrics are sent. The parameters are expressed as key = value
 #   pairs with no white space. The main parameter is the choice of server:
@@ -1311,7 +1320,7 @@
 #
 #       Choice of server to send metrics to. Currently the only choice is
 #       "statsd" which sends UDP packets to a StatsD daemon, which must be
-#       running while rippled is running. More information on StatsD is
+#       running while xahaud is running. More information on StatsD is
 #       available here:
 #           https://github.com/b/statsd_spec
 #
@@ -1321,7 +1330,7 @@
 #                 in the format, n.n.n.n:port.
 #
 #       "prefix"  A string prepended to each collected metric. This is used
-#                 to distinguish between different running instances of rippled.
+#                 to distinguish between different running instances of xahaud.
 #
 #     If this section is missing, or the server type is unspecified or unknown,
 #     statistics are not collected or reported.
@@ -1348,7 +1357,7 @@
 #
 #   Example:
 #     [perf]
-#     perf_log=/var/log/rippled/perf.log
+#     perf_log=/var/log/xahaud/perf.log
 #     log_interval=2
 #
 #-------------------------------------------------------------------------------
@@ -1357,8 +1366,8 @@
 #
 #----------
 #
-#   The vote settings configure settings for the entire Ripple network.
-#   While a single instance of rippled cannot unilaterally enforce network-wide
+#   The vote settings configure settings for the entire Xahau Network.
+#   While a single instance of xahaud cannot unilaterally enforce network-wide
 #   settings, these choices become part of the instance's vote during the
 #   consensus process for each voting ledger.
 #
@@ -1370,9 +1379,9 @@
 #
 #       The cost of the reference transaction fee, specified in drops.
 #       The reference transaction is the simplest form of transaction.
-#       It represents an XRP payment between two parties.
+#       It represents an XAH payment between two parties.
 #
-#       If this parameter is unspecified, rippled will use an internal
+#       If this parameter is unspecified, xahaud will use an internal
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
@@ -1381,26 +1390,26 @@
 #   account_reserve = <drops>
 #
 #       The account reserve requirement is specified in drops. The portion of an
-#       account's XRP balance that is at or below the reserve may only be
+#       account's XAH balance that is at or below the reserve may only be
 #       spent on transaction fees, and not transferred out of the account.
 #
-#       If this parameter is unspecified, rippled will use an internal
+#       If this parameter is unspecified, xahaud will use an internal
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           account_reserve = 10000000   # 10 XRP
+#           account_reserve = 10000000   # 10 XAH
 #
 #   owner_reserve = <drops>
 #
-#       The owner reserve is the amount of XRP reserved in the account for
+#       The owner reserve is the amount of XAH reserved in the account for
 #       each ledger item owned by the account. Ledger items an account may
 #       own include trust lines, open orders, and tickets.
 #
-#       If this parameter is unspecified, rippled will use an internal
+#       If this parameter is unspecified, xahaud will use an internal
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           owner_reserve = 2000000      # 2 XRP
+#           owner_reserve = 2000000      # 2 XAH
 #
 #-------------------------------------------------------------------------------
 #
@@ -1438,7 +1447,7 @@
 #   tool instead.
 #
 #   This flag has no effect on the "sign" and "sign_for" command line options
-#   that rippled makes available.
+#   that xahaud makes available.
 #
 #   The default value of this field is "false"
 #
@@ -1517,7 +1526,7 @@
 #--------------------
 #
 #   Administrators can use these values as a starting point for configuring
-#   their instance of rippled, but each value should be checked to make sure
+#   their instance of xahaud, but each value should be checked to make sure
 #   it meets the business requirements for the organization.
 #
 # Server
@@ -1527,7 +1536,7 @@
 #   "peer"
 #
 #       Peer protocol open to everyone. This is required to accept
-#       incoming rippled connections. This does not affect automatic
+#       incoming xahaud connections. This does not affect automatic
 #       or manual outgoing Peer protocol connections.
 #
 #   "rpc"
@@ -1555,8 +1564,8 @@
 #   NOTE
 #
 #       To accept connections on well known ports such as 80 (HTTP) or
-#       443 (HTTPS), most operating systems will require rippled to
-#       run with administrator privileges, or else rippled will not start.
+#       443 (HTTPS), most operating systems will require xahaud to
+#       run with administrator privileges, or else xahaud will not start.
 
 [server]
 port_rpc_admin_local
@@ -1574,7 +1583,7 @@ admin = 127.0.0.1
 protocol = http
 
 [port_peer]
-port = 51235
+port = 21337
 ip = 0.0.0.0
 # alternatively, to accept connections on IPv4 + IPv6, use:
 #ip = ::
@@ -1598,9 +1607,9 @@ protocol = ws
 
 #-------------------------------------------------------------------------------
 
-# This is primary persistent datastore for rippled.  This includes transaction
+# This is primary persistent datastore for xahaud.  This includes transaction
 # metadata, account states, and ledger headers.  Helpful information can be
-# found at https://xrpl.org/capacity-planning.html#node-db-type
+# found at https://xahau.network/docs/infrastructure/system-requirements
 # type=NuDB is recommended for non-validators with fast SSDs. Validators or
 #    slow / spinning disks should use RocksDB. Caution: Spinning disks are
 #    not recommended. They do not perform well enough to consistently remain
@@ -1613,16 +1622,16 @@ protocol = ws
 #    deletion.
 [node_db]
 type=NuDB
-path=/var/lib/rippled-reporting/db/nudb
+path=/opt/xahaud-reporting/db/nudb
 # online_delete=512 #
 advisory_delete=0
 
 # This is the persistent datastore for shards. It is important for the health
-# of the ripple network that rippled operators shard as much as practical.
+# of the Xahau Network that xahaud operators shard as much as practical.
 # NuDB requires SSD storage. Helpful information can be found at
 # https://xrpl.org/history-sharding.html
 #[shard_db]
-#path=/var/lib/rippled/db/shards/nudb
+#path=/opt/xahaud-reporting/db/shards/nudb
 #max_historical_shards=50
 #
 # This optional section can be configured with a list
@@ -1633,7 +1642,7 @@ advisory_delete=0
 #/path/2
 
 [database_path]
-/var/lib/rippled-reporting/db
+/opt/xahaud-reporting/db
 
 # To use Postgres, uncomment this section and fill in the appropriate connection
 # info. Postgres can only be used in Reporting Mode.
@@ -1647,19 +1656,28 @@ advisory_delete=0
 # This needs to be an absolute directory reference, not a relative one.
 # Modify this value as required.
 [debug_logfile]
-/var/log/rippled-reporting/debug.log
+/var/log/xahaud-reporting/debug.log
 
-# To use the XRP test network
-# (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
+[sntp_servers]
+time.windows.com
+time.apple.com
+time.nist.gov
+pool.ntp.org
+
+# To use the Xahau Test Network
+# (see https://xahau.network/docs/infrastructure/installing-xahaud),
 # use the following [ips] section:
 # [ips]
-# r.altnet.rippletest.net 51235
+# 79.110.60.121 21338
+# 79.110.60.122 21338
+# 79.110.60.124 21338
+# 79.110.60.125 21338
 
 # File containing trusted validator keys or validator list publishers.
 # Unless an absolute path is specified, it will be considered relative to the
-# folder in which the rippled.cfg file is located.
+# folder in which the xahaud.cfg file is located.
 [validators_file]
-/opt/rippled-reporting/etc/validators.txt
+/opt/xahaud-reporting/etc/validators.txt
 
 # Turn down default logging to save disk space in the long run.
 # Valid values here are trace, debug, info, warning, error, and fatal
@@ -1680,5 +1698,5 @@ etl_source
 
 [etl_source]
 source_grpc_port=50051
-source_ws_port=6005
+source_ws_port=6008
 source_ip=127.0.0.1

cfg/xahaud-standalone.cfg

@@ -1,4 +1,4 @@
-# standalone: ./rippled -a --ledgerfile config/genesis.json --conf config/rippled-standalone.cfg
+# standalone: ./xahaud -a --ledgerfile config/genesis.json --conf config/xahaud-standalone.cfg
 [server]
 port_rpc_admin_local
 port_ws_public
@@ -21,7 +21,7 @@ ip = 0.0.0.0
 protocol = ws
 
 # [port_peer]
-# port = 51235
+# port = 21337
 # ip = 0.0.0.0
 # protocol = peer
 
@@ -69,7 +69,8 @@ time.nist.gov
 pool.ntp.org
 
 [ips]
-r.ripple.com 51235
+bacab.alloy.ee 21337
+hubs.xahau.as16089.net 21337
 
 [validators_file]
 validators-example.txt
@@ -94,7 +95,7 @@ validators-example.txt
 1000000
 
 [network_id]
-21338
+21337
 
 [amendments]
 740352F2412A9909880C23A559FCECEDA3BE2126FED62FC7660D628A06927F11 Flow

conanfile.py

@@ -21,27 +21,20 @@ class Xrpl(ConanFile):
         'static': [True, False],
         'tests': [True, False],
         'unity': [True, False],
+        'with_wasmedge': [True, False],
+        'tool_requires_b2': [True, False],
     }
 
     requires = [
-        'boost/1.86.0',
-        'date/3.0.1',
+        'date/3.0.3',
         'libarchive/3.6.0',
-        'lz4/1.9.3',
+        'lz4/1.9.4',
         'grpc/1.50.1',
         'nudb/2.0.8',
-        'openssl/1.1.1u',
-        'protobuf/3.21.9',
-        'snappy/1.1.10',
-        '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',
+        'openssl/3.6.0',
+        'protobuf/3.21.12',
+        'soci/4.0.3@xahaud/stable',
+        'zlib/1.3.1',
     ]
 
     default_options = {
@@ -55,43 +48,44 @@ class Xrpl(ConanFile):
         'static': True,
         'tests': True,
         'unity': False,
+        'with_wasmedge': True,
+        'tool_requires_b2': False,
 
-        'cassandra-cpp-driver:shared': False,
-        'date:header_only': True,
-        'grpc:shared': False,
-        'grpc:secure': True,
-        'libarchive:shared': False,
-        'libarchive:with_acl': False,
-        'libarchive:with_bzip2': False,
-        'libarchive:with_cng': False,
-        'libarchive:with_expat': False,
-        'libarchive:with_iconv': False,
-        'libarchive:with_libxml2': False,
-        'libarchive:with_lz4': True,
-        'libarchive:with_lzma': False,
-        'libarchive:with_lzo': False,
-        'libarchive:with_nettle': False,
-        'libarchive:with_openssl': False,
-        'libarchive:with_pcreposix': False,
-        'libarchive:with_xattr': False,
-        'libarchive:with_zlib': False,
-        'libpq:shared': False,
-        'lz4:shared': False,
-        'openssl:shared': False,
-        'protobuf:shared': False,
-        'protobuf:with_zlib': True,
-        'rocksdb:enable_sse': False,
-        'rocksdb:lite': False,
-        'rocksdb:shared': False,
-        'rocksdb:use_rtti': True,
-        'rocksdb:with_jemalloc': False,
-        'rocksdb:with_lz4': True,
-        'rocksdb:with_snappy': True,
-        'snappy:shared': False,
-        'soci:shared': False,
-        'soci:with_sqlite3': True,
-        'soci:with_boost': True,
-        'xxhash:shared': False,
+        'cassandra-cpp-driver/*:shared': False,
+        'date/*:header_only': False,
+        'grpc/*:shared': False,
+        'grpc/*:secure': True,
+        'libarchive/*:shared': False,
+        'libarchive/*:with_acl': False,
+        'libarchive/*:with_bzip2': False,
+        'libarchive/*:with_cng': False,
+        'libarchive/*:with_expat': False,
+        'libarchive/*:with_iconv': False,
+        'libarchive/*:with_libxml2': False,
+        'libarchive/*:with_lz4': True,
+        'libarchive/*:with_lzma': False,
+        'libarchive/*:with_lzo': False,
+        'libarchive/*:with_nettle': False,
+        'libarchive/*:with_openssl': False,
+        'libarchive/*:with_pcreposix': False,
+        'libarchive/*:with_xattr': False,
+        'libarchive/*:with_zlib': False,
+        'libpq/*:shared': False,
+        'lz4/*:shared': False,
+        'openssl/*:shared': False,
+        'protobuf/*:shared': False,
+        'protobuf/*:with_zlib': True,
+        'rocksdb/*:enable_sse': False,
+        'rocksdb/*:lite': False,
+        'rocksdb/*:shared': False,
+        'rocksdb/*:use_rtti': True,
+        'rocksdb/*:with_jemalloc': False,
+        'rocksdb/*:with_lz4': True,
+        'rocksdb/*:with_snappy': True,
+        'snappy/*:shared': False,
+        'soci/*:shared': False,
+        'soci/*:with_sqlite3': True,
+        'soci/*:with_boost': True,
     }
 
     def set_version(self):
@@ -102,11 +96,28 @@ class Xrpl(ConanFile):
             match = next(m for m in matches if m)
             self.version = match.group(1)
 
+    def build_requirements(self):
+        # These provide build tools (protoc, grpc plugins) that run during build
+        self.tool_requires('protobuf/3.21.12')
+        self.tool_requires('grpc/1.50.1')
+        # Explicitly require b2 (e.g. for building from source for glibc compatibility)
+        if self.options.tool_requires_b2:
+            self.tool_requires('b2/5.3.2')
+
     def configure(self):
         if self.settings.compiler == 'apple-clang':
-            self.options['boost'].visibility = 'global'
+            self.options['boost/*'].visibility = 'global'
 
     def requirements(self):
+        # Force sqlite3 version to avoid conflicts with soci
+        self.requires('sqlite3/3.42.0', override=True)
+        # Force our custom snappy build for all dependencies
+        self.requires('snappy/1.1.10@xahaud/stable', override=True)
+        # Force boost version for all dependencies to avoid conflicts
+        self.requires('boost/1.86.0', override=True)
+
+        if self.options.with_wasmedge:
+            self.requires('wasmedge/0.11.2@xahaud/stable')
         if self.options.jemalloc:
             self.requires('jemalloc/5.2.1')
         if self.options.reporting:
@@ -116,7 +127,7 @@ class Xrpl(ConanFile):
             self.requires('rocksdb/6.27.3')
 
     exports_sources = (
-        'CMakeLists.txt', 'Builds/*', 'bin/getRippledInfo', 'src/*', 'cfg/*', 'external/*'
+        'CMakeLists.txt', 'Builds/*', 'bin/getRippledInfo', 'src/*', 'cfg/*'
     )
 
     def layout(self):
@@ -153,18 +164,9 @@ class Xrpl(ConanFile):
     def package_info(self):
         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',
+            'libxrpl_core.a',
+            'libed25519.a',
+            'libsecp256k1.a',
         ]
+        libxrpl.includedirs = ['include']
+        libxrpl.requires = ['boost::boost']

docker-unit-tests.sh

@@ -8,4 +8,4 @@ if [[ "$GITHUB_REPOSITORY" == "" ]]; then
 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'
+docker run --rm -i -v $(pwd):/io --platform=linux/amd64 -e BUILD_CORES=$BUILD_CORES ubuntu sh -c '/io/release-build/xahaud --unittest-jobs $BUILD_CORES -u'

external/README.md

@@ -1,11 +0,0 @@
-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. |

external/rocksdb/conandata.yml

@@ -1,27 +0,0 @@
-sources:
-  "6.29.5":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.29.5.tar.gz"
-    sha256: "ddbf84791f0980c0bbce3902feb93a2c7006f6f53bfd798926143e31d4d756f0"
-  "6.27.3":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.27.3.tar.gz"
-    sha256: "ee29901749b9132692b26f0a6c1d693f47d1a9ed8e3771e60556afe80282bf58"
-  "6.20.3":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.20.3.tar.gz"
-    sha256: "c6502c7aae641b7e20fafa6c2b92273d935d2b7b2707135ebd9a67b092169dca"
-  "8.8.1":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v8.8.1.tar.gz"
-    sha256: "056c7e21ad8ae36b026ac3b94b9d6e0fcc60e1d937fc80330921e4181be5c36e"
-patches:
-  "6.29.5":
-    - patch_file: "patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch"
-      patch_description: "Fix build with gcc 13 by including cstdint"
-      patch_type: "portability"
-      patch_source: "https://github.com/facebook/rocksdb/pull/11118"
-    - patch_file: "patches/6.29.5-0002-exclude-thirdparty.patch"
-      patch_description: "Do not include thirdparty.inc"
-      patch_type: "portability"
-  "6.27.3":
-    - patch_file: "patches/6.27.3-0001-add-include-cstdint-for-gcc-13.patch"
-      patch_description: "Fix build with gcc 13 by including cstdint"
-      patch_type: "portability"
-      patch_source: "https://github.com/facebook/rocksdb/pull/11118"

external/rocksdb/conanfile.py

@@ -1,233 +1,193 @@
 import os
-import glob
 import shutil
+from conans import ConanFile, CMake
+from conan.tools import microsoft as ms
 
-from conan import ConanFile
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.build import check_min_cppstd
-from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
-from conan.tools.files import apply_conandata_patches, collect_libs, copy, export_conandata_patches, get, rm, rmdir
-from conan.tools.microsoft import check_min_vs, is_msvc, is_msvc_static_runtime
-from conan.tools.scm import Version
+class RocksDB(ConanFile):
+    name = 'rocksdb'
+    version = '6.27.3'
 
-required_conan_version = ">=1.53.0"
+    license = ('GPL-2.0-only', 'Apache-2.0')
+    url = 'https://github.com/conan-io/conan-center-index'
+    description = 'A library that provides an embeddable, persistent key-value store for fast storage'
+    topics = ('rocksdb', 'database', 'leveldb', 'facebook', 'key-value')
 
-
-class RocksDBConan(ConanFile):
-    name = "rocksdb"
-    homepage = "https://github.com/facebook/rocksdb"
-    license = ("GPL-2.0-only", "Apache-2.0")
-    url = "https://github.com/conan-io/conan-center-index"
-    description = "A library that provides an embeddable, persistent key-value store for fast storage"
-    topics = ("database", "leveldb", "facebook", "key-value")
-    package_type = "library"
-    settings = "os", "arch", "compiler", "build_type"
+    settings = 'os', 'compiler', 'build_type', 'arch'
     options = {
-        "shared": [True, False],
-        "fPIC": [True, False],
-        "lite": [True, False],
-        "with_gflags": [True, False],
-        "with_snappy": [True, False],
-        "with_lz4": [True, False],
-        "with_zlib": [True, False],
-        "with_zstd": [True, False],
-        "with_tbb": [True, False],
-        "with_jemalloc": [True, False],
-        "enable_sse": [False, "sse42", "avx2"],
-        "use_rtti": [True, False],
+        'enable_sse': [False, 'sse42', 'avx2'],
+        'fPIC': [True, False],
+        'lite': [True, False],
+        'shared': [True, False],
+        'use_rtti': [True, False],
+        'with_gflags': [True, False],
+        'with_jemalloc': [True, False],
+        'with_lz4': [True, False],
+        'with_snappy': [True, False],
+        'with_tbb': [True, False],
+        'with_zlib': [True, False],
+        'with_zstd': [True, False],
     }
     default_options = {
-        "shared": False,
-        "fPIC": True,
-        "lite": False,
-        "with_snappy": False,
-        "with_lz4": False,
-        "with_zlib": False,
-        "with_zstd": False,
-        "with_gflags": False,
-        "with_tbb": False,
-        "with_jemalloc": False,
-        "enable_sse": False,
-        "use_rtti": False,
+        'enable_sse': False,
+        'fPIC': True,
+        'lite': False,
+        'shared': False,
+        'use_rtti': False,
+        'with_gflags': False,
+        'with_jemalloc': False,
+        'with_lz4': False,
+        'with_snappy': False,
+        'with_tbb': False,
+        'with_zlib': False,
+        'with_zstd': False,
     }
 
-    @property
-    def _min_cppstd(self):
-        return "11" if Version(self.version) < "8.8.1" else "17"
-
-    @property
-    def _compilers_minimum_version(self):
-        return {} if self._min_cppstd == "11" else {
-                "apple-clang": "10",
-                "clang": "7",
-                "gcc": "7",
-                "msvc": "191",
-                "Visual Studio": "15",
-            }
-
-    def export_sources(self):
-        export_conandata_patches(self)
-
-    def config_options(self):
-        if self.settings.os == "Windows":
-            del self.options.fPIC
-        if self.settings.arch != "x86_64":
-            del self.options.with_tbb
-        if self.settings.build_type == "Debug":
-            self.options.use_rtti = True  # Rtti are used in asserts for debug mode...
-
-    def configure(self):
-        if self.options.shared:
-            self.options.rm_safe("fPIC")
-
-    def layout(self):
-        cmake_layout(self, src_folder="src")
-
     def requirements(self):
         if self.options.with_gflags:
-            self.requires("gflags/2.2.2")
-        if self.options.with_snappy:
-            self.requires("snappy/1.1.10")
+            self.requires('gflags/2.2.2')
+        if self.options.with_jemalloc:
+            self.requires('jemalloc/5.2.1')
         if self.options.with_lz4:
-            self.requires("lz4/1.9.4")
+            self.requires('lz4/1.9.3')
+        if self.options.with_snappy:
+            self.requires('snappy/1.1.9')
+        if self.options.with_tbb:
+            self.requires('onetbb/2020.3')
         if self.options.with_zlib:
-            self.requires("zlib/[>=1.2.11 <2]")
+            self.requires('zlib/1.2.11')
         if self.options.with_zstd:
-            self.requires("zstd/1.5.5")
-        if self.options.get_safe("with_tbb"):
-            self.requires("onetbb/2021.10.0")
-        if self.options.with_jemalloc:
-            self.requires("jemalloc/5.3.0")
+            self.requires('zstd/1.5.2')
 
-    def validate(self):
-        if self.settings.compiler.get_safe("cppstd"):
-            check_min_cppstd(self, self._min_cppstd)
+    def config_options(self):
+        if self.settings.os == 'Windows':
+            del self.options.fPIC
 
-        minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
-        if minimum_version and Version(self.settings.compiler.version) < minimum_version:
-            raise ConanInvalidConfiguration(
-                f"{self.ref} requires C++{self._min_cppstd}, which your compiler does not support."
+    def configure(self):
+        if self.options.shared:
+            del self.options.fPIC
+
+    generators = 'cmake', 'cmake_find_package'
+
+    scm = {
+        'type': 'git',
+        'url': 'https://github.com/facebook/rocksdb.git',
+        'revision': 'v6.27.3',
+    }
+
+    exports_sources = 'thirdparty.inc'
+    # For out-of-source build.
+    no_copy_source = True
+
+    _cmake = None
+
+    def _configure_cmake(self):
+        if self._cmake:
+            return
+
+        self._cmake = CMake(self)
+
+        self._cmake.definitions['CMAKE_POSITION_INDEPENDENT_CODE'] = True
+
+        self._cmake.definitions['DISABLE_STALL_NOTIF'] = False
+        self._cmake.definitions['FAIL_ON_WARNINGS'] = False
+        self._cmake.definitions['OPTDBG'] = True
+        self._cmake.definitions['WITH_TESTS'] = False
+        self._cmake.definitions['WITH_TOOLS'] = False
+
+        self._cmake.definitions['WITH_GFLAGS'] = self.options.with_gflags
+        self._cmake.definitions['WITH_JEMALLOC'] = self.options.with_jemalloc
+        self._cmake.definitions['WITH_LZ4'] = self.options.with_lz4
+        self._cmake.definitions['WITH_SNAPPY'] = self.options.with_snappy
+        self._cmake.definitions['WITH_TBB'] = self.options.with_tbb
+        self._cmake.definitions['WITH_ZLIB'] = self.options.with_zlib
+        self._cmake.definitions['WITH_ZSTD'] = self.options.with_zstd
+
+        self._cmake.definitions['USE_RTTI'] = self.options.use_rtti
+        self._cmake.definitions['ROCKSDB_LITE'] = self.options.lite
+        self._cmake.definitions['ROCKSDB_INSTALL_ON_WINDOWS'] = (
+            self.settings.os == 'Windows'
+        )
+
+        if not self.options.enable_sse:
+            self._cmake.definitions['PORTABLE'] = True
+            self._cmake.definitions['FORCE_SSE42'] = False
+        elif self.options.enable_sse == 'sse42':
+            self._cmake.definitions['PORTABLE'] = True
+            self._cmake.definitions['FORCE_SSE42'] = True
+        elif self.options.enable_sse == 'avx2':
+            self._cmake.definitions['PORTABLE'] = False
+            self._cmake.definitions['FORCE_SSE42'] = False
+
+        self._cmake.definitions['WITH_ASAN'] = False
+        self._cmake.definitions['WITH_BZ2'] = False
+        self._cmake.definitions['WITH_JNI'] = False
+        self._cmake.definitions['WITH_LIBRADOS'] = False
+        if ms.is_msvc(self):
+            self._cmake.definitions['WITH_MD_LIBRARY'] = (
+                ms.msvc_runtime_flag(self).startswith('MD')
             )
+            self._cmake.definitions['WITH_RUNTIME_DEBUG'] = (
+                ms.msvc_runtime_flag(self).endswith('d')
+            )
+        self._cmake.definitions['WITH_NUMA'] = False
+        self._cmake.definitions['WITH_TSAN'] = False
+        self._cmake.definitions['WITH_UBSAN'] = False
+        self._cmake.definitions['WITH_WINDOWS_UTF8_FILENAMES'] = False
+        self._cmake.definitions['WITH_XPRESS'] = False
+        self._cmake.definitions['WITH_FALLOCATE'] = True
 
-        if self.settings.arch not in ["x86_64", "ppc64le", "ppc64", "mips64", "armv8"]:
-            raise ConanInvalidConfiguration("Rocksdb requires 64 bits")
-
-        check_min_vs(self, "191")
-
-        if self.version == "6.20.3" and \
-           self.settings.os == "Linux" and \
-           self.settings.compiler == "gcc" and \
-           Version(self.settings.compiler.version) < "5":
-            raise ConanInvalidConfiguration("Rocksdb 6.20.3 is not compilable with gcc <5.") # See https://github.com/facebook/rocksdb/issues/3522
-
-    def source(self):
-        get(self, **self.conan_data["sources"][self.version], strip_root=True)
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-        tc.variables["FAIL_ON_WARNINGS"] = False
-        tc.variables["WITH_TESTS"] = False
-        tc.variables["WITH_TOOLS"] = False
-        tc.variables["WITH_CORE_TOOLS"] = False
-        tc.variables["WITH_BENCHMARK_TOOLS"] = False
-        tc.variables["WITH_FOLLY_DISTRIBUTED_MUTEX"] = False
-        if is_msvc(self):
-            tc.variables["WITH_MD_LIBRARY"] = not is_msvc_static_runtime(self)
-        tc.variables["ROCKSDB_INSTALL_ON_WINDOWS"] = self.settings.os == "Windows"
-        tc.variables["ROCKSDB_LITE"] = self.options.lite
-        tc.variables["WITH_GFLAGS"] = self.options.with_gflags
-        tc.variables["WITH_SNAPPY"] = self.options.with_snappy
-        tc.variables["WITH_LZ4"] = self.options.with_lz4
-        tc.variables["WITH_ZLIB"] = self.options.with_zlib
-        tc.variables["WITH_ZSTD"] = self.options.with_zstd
-        tc.variables["WITH_TBB"] = self.options.get_safe("with_tbb", False)
-        tc.variables["WITH_JEMALLOC"] = self.options.with_jemalloc
-        tc.variables["ROCKSDB_BUILD_SHARED"] = self.options.shared
-        tc.variables["ROCKSDB_LIBRARY_EXPORTS"] = self.settings.os == "Windows" and self.options.shared
-        tc.variables["ROCKSDB_DLL" ] = self.settings.os == "Windows" and self.options.shared
-        tc.variables["USE_RTTI"] = self.options.use_rtti
-        if not bool(self.options.enable_sse):
-            tc.variables["PORTABLE"] = True
-            tc.variables["FORCE_SSE42"] = False
-        elif self.options.enable_sse == "sse42":
-            tc.variables["PORTABLE"] = True
-            tc.variables["FORCE_SSE42"] = True
-        elif self.options.enable_sse == "avx2":
-            tc.variables["PORTABLE"] = False
-            tc.variables["FORCE_SSE42"] = False
-        # not available yet in CCI
-        tc.variables["WITH_NUMA"] = False
-        tc.generate()
-
-        deps = CMakeDeps(self)
-        if self.options.with_jemalloc:
-            deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
-            deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
-        deps.generate()
 
     def build(self):
-        apply_conandata_patches(self)
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.build()
-
-    def _remove_static_libraries(self):
-        rm(self, "rocksdb.lib", os.path.join(self.package_folder, "lib"))
-        for lib in glob.glob(os.path.join(self.package_folder, "lib", "*.a")):
-            if not lib.endswith(".dll.a"):
-                os.remove(lib)
-
-    def _remove_cpp_headers(self):
-        for path in glob.glob(os.path.join(self.package_folder, "include", "rocksdb", "*")):
-            if path != os.path.join(self.package_folder, "include", "rocksdb", "c.h"):
-                if os.path.isfile(path):
-                    os.remove(path)
-                else:
-                    shutil.rmtree(path)
+        if ms.is_msvc(self):
+            file = os.path.join(
+                self.recipe_folder, '..', 'export_source', 'thirdparty.inc'
+            )
+            shutil.copy(file, self.build_folder)
+        self._configure_cmake()
+        self._cmake.configure()
+        self._cmake.build()
 
     def package(self):
-        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
-        copy(self, "LICENSE*", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
-        cmake = CMake(self)
-        cmake.install()
-        if self.options.shared:
-            self._remove_static_libraries()
-            self._remove_cpp_headers() # Force stable ABI for shared libraries
-        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
-        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+        self._configure_cmake()
+        self._cmake.install()
 
     def package_info(self):
-        cmake_target = "rocksdb-shared" if self.options.shared else "rocksdb"
-        self.cpp_info.set_property("cmake_file_name", "RocksDB")
-        self.cpp_info.set_property("cmake_target_name", f"RocksDB::{cmake_target}")
-        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.components["librocksdb"].libs = collect_libs(self)
+        self.cpp_info.filenames['cmake_find_package'] = 'RocksDB'
+        self.cpp_info.filenames['cmake_find_package_multi'] = 'RocksDB'
+        self.cpp_info.set_property('cmake_file_name', 'RocksDB')
+
+        self.cpp_info.names['cmake_find_package'] = 'RocksDB'
+        self.cpp_info.names['cmake_find_package_multi'] = 'RocksDB'
+
+        self.cpp_info.components['librocksdb'].names['cmake_find_package'] = 'rocksdb'
+        self.cpp_info.components['librocksdb'].names['cmake_find_package_multi'] = 'rocksdb'
+        self.cpp_info.components['librocksdb'].set_property(
+            'cmake_target_name', 'RocksDB::rocksdb'
+        )
+
+        self.cpp_info.components['librocksdb'].libs = ['rocksdb']
+
         if self.settings.os == "Windows":
             self.cpp_info.components["librocksdb"].system_libs = ["shlwapi", "rpcrt4"]
             if self.options.shared:
                 self.cpp_info.components["librocksdb"].defines = ["ROCKSDB_DLL"]
         elif self.settings.os in ["Linux", "FreeBSD"]:
             self.cpp_info.components["librocksdb"].system_libs = ["pthread", "m"]
+
         if self.options.lite:
             self.cpp_info.components["librocksdb"].defines.append("ROCKSDB_LITE")
 
-        # TODO: to remove in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.names["cmake_find_package"] = "RocksDB"
-        self.cpp_info.names["cmake_find_package_multi"] = "RocksDB"
-        self.cpp_info.components["librocksdb"].names["cmake_find_package"] = cmake_target
-        self.cpp_info.components["librocksdb"].names["cmake_find_package_multi"] = cmake_target
-        self.cpp_info.components["librocksdb"].set_property("cmake_target_name", f"RocksDB::{cmake_target}")
         if self.options.with_gflags:
             self.cpp_info.components["librocksdb"].requires.append("gflags::gflags")
-        if self.options.with_snappy:
-            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_jemalloc:
+            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")
         if self.options.with_lz4:
             self.cpp_info.components["librocksdb"].requires.append("lz4::lz4")
+        if self.options.with_snappy:
+            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_tbb:
+            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
         if self.options.with_zlib:
             self.cpp_info.components["librocksdb"].requires.append("zlib::zlib")
         if self.options.with_zstd:
             self.cpp_info.components["librocksdb"].requires.append("zstd::zstd")
-        if self.options.get_safe("with_tbb"):
-            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
-        if self.options.with_jemalloc:
-            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")

external/rocksdb/patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch

@@ -1,30 +0,0 @@
---- a/include/rocksdb/utilities/checkpoint.h
-+++ b/include/rocksdb/utilities/checkpoint.h
-@@ -8,6 +8,7 @@
- #pragma once
- #ifndef ROCKSDB_LITE
- 
-+#include <cstdint>
- #include <string>
- #include <vector>
- #include "rocksdb/status.h"
---- a/table/block_based/data_block_hash_index.h
-+++ b/table/block_based/data_block_hash_index.h
-@@ -5,6 +5,7 @@
- 
- #pragma once
- 
-+#include <cstdint>
- #include <string>
- #include <vector>
- 
---- a/util/string_util.h
-+++ b/util/string_util.h
-@@ -6,6 +6,7 @@
- 
- #pragma once
- 
-+#include <cstdint>
- #include <sstream>
- #include <string>
- #include <unordered_map>

external/rocksdb/patches/6.29.5-0002-exclude-thirdparty.patch

@@ -1,16 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index ec59d4491..35577c998 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -101 +100,0 @@ if(MSVC)
--  option(WITH_GFLAGS "build with GFlags" OFF)
-@@ -103,2 +102,2 @@ if(MSVC)
--  include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
--else()
-+endif()
-+
-@@ -117 +116 @@ else()
--  if(MINGW)
-+  if(MINGW OR MSVC)
-@@ -183 +181,0 @@ else()
--endif()

external/secp256k1/.cirrus.yml

@@ -1,409 +0,0 @@
-env:
-  ### cirrus config
-  CIRRUS_CLONE_DEPTH: 1
-  ### compiler options
-  HOST:
-  WRAPPER_CMD:
-  # Specific warnings can be disabled with -Wno-error=foo.
-  # -pedantic-errors is not equivalent to -Werror=pedantic and thus not implied by -Werror according to the GCC manual.
-  WERROR_CFLAGS: -Werror -pedantic-errors
-  MAKEFLAGS: -j4
-  BUILD: check
-  ### secp256k1 config
-  ECMULTWINDOW: auto
-  ECMULTGENPRECISION: auto
-  ASM: no
-  WIDEMUL: auto
-  WITH_VALGRIND: yes
-  EXTRAFLAGS:
-  ### secp256k1 modules
-  EXPERIMENTAL: no
-  ECDH: no
-  RECOVERY: no
-  SCHNORRSIG: no
-  ### test options
-  SECP256K1_TEST_ITERS:
-  BENCH: yes
-  SECP256K1_BENCH_ITERS: 2
-  CTIMETESTS: yes
-  # Compile and run the tests
-  EXAMPLES: yes
-
-# https://cirrus-ci.org/pricing/#compute-credits
-credits_snippet: &CREDITS
-  # Don't use any credits for now.
-  use_compute_credits: false
-
-cat_logs_snippet: &CAT_LOGS
-  always:
-    cat_tests_log_script:
-      - cat tests.log || true
-    cat_noverify_tests_log_script:
-      - cat noverify_tests.log || true
-    cat_exhaustive_tests_log_script:
-      - cat exhaustive_tests.log || true
-    cat_ctime_tests_log_script:
-      - cat ctime_tests.log || true
-    cat_bench_log_script:
-      - cat bench.log || true
-    cat_config_log_script:
-      - cat config.log || true
-    cat_test_env_script:
-      - cat test_env.log || true
-    cat_ci_env_script:
-      - env
-
-merge_base_script_snippet: &MERGE_BASE
-  merge_base_script:
-    - if [ "$CIRRUS_PR" = "" ]; then exit 0; fi
-    - git fetch --depth=1 $CIRRUS_REPO_CLONE_URL "pull/${CIRRUS_PR}/merge"
-    - git checkout FETCH_HEAD  # Use merged changes to detect silent merge conflicts
-
-linux_container_snippet: &LINUX_CONTAINER
-  container:
-    dockerfile: ci/linux-debian.Dockerfile
-    # Reduce number of CPUs to be able to do more builds in parallel.
-    cpu: 1
-    # Gives us more CPUs for free if they're available.
-    greedy: true
-    # More than enough for our scripts.
-    memory: 1G
-
-task:
-  name: "x86_64: Linux (Debian stable)"
-  << : *LINUX_CONTAINER
-  matrix: &ENV_MATRIX
-    - env: {WIDEMUL:  int64,  RECOVERY: yes}
-    - env: {WIDEMUL:  int64,                 ECDH: yes, SCHNORRSIG: yes}
-    - env: {WIDEMUL: int128}
-    - env: {WIDEMUL: int128_struct}
-    - env: {WIDEMUL: int128,  RECOVERY: yes,            SCHNORRSIG: yes}
-    - env: {WIDEMUL: int128,                 ECDH: yes, SCHNORRSIG: yes}
-    - env: {WIDEMUL: int128,  ASM: x86_64}
-    - env: {                  RECOVERY: yes,            SCHNORRSIG: yes}
-    - env: {CTIMETESTS: no,    RECOVERY: yes, ECDH: yes, SCHNORRSIG: yes, CPPFLAGS: -DVERIFY}
-    - env: {BUILD: distcheck, WITH_VALGRIND: no, CTIMETESTS: no, BENCH: no}
-    - env: {CPPFLAGS: -DDETERMINISTIC}
-    - env: {CFLAGS: -O0, CTIMETESTS: no}
-    - env: { ECMULTGENPRECISION: 2, ECMULTWINDOW: 2 }
-    - env: { ECMULTGENPRECISION: 8, ECMULTWINDOW: 4 }
-  matrix:
-    - env:
-        CC: gcc
-    - env:
-        CC: clang
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "i686: Linux (Debian stable)"
-  << : *LINUX_CONTAINER
-  env:
-    HOST: i686-linux-gnu
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-  matrix:
-    - env:
-        CC: i686-linux-gnu-gcc
-    - env:
-        CC: clang --target=i686-pc-linux-gnu -isystem /usr/i686-linux-gnu/include
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "arm64: macOS Ventura"
-  macos_instance:
-    image: ghcr.io/cirruslabs/macos-ventura-base:latest
-  env:
-    HOMEBREW_NO_AUTO_UPDATE: 1
-    HOMEBREW_NO_INSTALL_CLEANUP: 1
-    # Cirrus gives us a fixed number of 4 virtual CPUs. Not that we even have that many jobs at the moment...
-    MAKEFLAGS: -j5
-  matrix:
-    << : *ENV_MATRIX
-  env:
-    ASM: no
-    WITH_VALGRIND: no
-    CTIMETESTS: no
-  matrix:
-    - env:
-        CC: gcc
-    - env:
-        CC: clang
-  brew_script:
-    - brew install automake libtool gcc
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-  << : *CREDITS
-
-task:
-  name: "s390x (big-endian): Linux (Debian stable, QEMU)"
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: qemu-s390x
-    SECP256K1_TEST_ITERS: 16
-    HOST: s390x-linux-gnu
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  << : *MERGE_BASE
-  test_script:
-    # https://sourceware.org/bugzilla/show_bug.cgi?id=27008
-    - rm /etc/ld.so.cache
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "ARM32: Linux (Debian stable, QEMU)"
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: qemu-arm
-    SECP256K1_TEST_ITERS: 16
-    HOST: arm-linux-gnueabihf
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  matrix:
-    - env: {}
-    - env: {EXPERIMENTAL: yes, ASM: arm32}
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "ARM64: Linux (Debian stable, QEMU)"
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: qemu-aarch64
-    SECP256K1_TEST_ITERS: 16
-    HOST: aarch64-linux-gnu
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "ppc64le: Linux (Debian stable, QEMU)"
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: qemu-ppc64le
-    SECP256K1_TEST_ITERS: 16
-    HOST: powerpc64le-linux-gnu
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: wine
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  matrix:
-    - name: "x86_64 (mingw32-w64): Windows (Debian stable, Wine)"
-      env:
-        HOST: x86_64-w64-mingw32
-    - name: "i686 (mingw32-w64): Windows (Debian stable, Wine)"
-      env:
-        HOST: i686-w64-mingw32
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  << : *LINUX_CONTAINER
-  env:
-    WRAPPER_CMD: wine
-    WERROR_CFLAGS: -WX
-    WITH_VALGRIND: no
-    ECDH: yes
-    RECOVERY: yes
-    EXPERIMENTAL: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-    # Use a MinGW-w64 host to tell ./configure we're building for Windows.
-    # This will detect some MinGW-w64 tools but then make will need only
-    # the MSVC tools CC, AR and NM as specified below.
-    HOST: x86_64-w64-mingw32
-    CC: /opt/msvc/bin/x64/cl
-    AR: /opt/msvc/bin/x64/lib
-    NM: /opt/msvc/bin/x64/dumpbin -symbols -headers
-    # Set non-essential options that affect the CLI messages here.
-    # (They depend on the user's taste, so we don't want to set them automatically in configure.ac.)
-    CFLAGS: -nologo -diagnostics:caret
-    LDFLAGS: -Xlinker -Xlinker -Xlinker -nologo
-  matrix:
-    - name: "x86_64 (MSVC): Windows (Debian stable, Wine)"
-    - name: "x86_64 (MSVC): Windows (Debian stable, Wine, int128_struct)"
-      env:
-        WIDEMUL: int128_struct
-    - name: "x86_64 (MSVC): Windows (Debian stable, Wine, int128_struct with __(u)mulh)"
-      env:
-        WIDEMUL: int128_struct
-        CPPFLAGS: -DSECP256K1_MSVC_MULH_TEST_OVERRIDE
-    - name: "i686 (MSVC): Windows (Debian stable, Wine)"
-      env:
-        HOST: i686-w64-mingw32
-        CC: /opt/msvc/bin/x86/cl
-        AR: /opt/msvc/bin/x86/lib
-        NM: /opt/msvc/bin/x86/dumpbin -symbols -headers
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-# Sanitizers
-task:
-  << : *LINUX_CONTAINER
-  env:
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: no
-  matrix:
-    - name: "Valgrind (memcheck)"
-      container:
-        cpu: 2
-      env:
-        # The `--error-exitcode` is required to make the test fail if valgrind found errors, otherwise it'll return 0 (https://www.valgrind.org/docs/manual/manual-core.html)
-        WRAPPER_CMD: "valgrind --error-exitcode=42"
-        SECP256K1_TEST_ITERS: 2
-    - name: "UBSan, ASan, LSan"
-      container:
-        memory: 2G
-      env:
-        CFLAGS: "-fsanitize=undefined,address -g"
-        UBSAN_OPTIONS: "print_stacktrace=1:halt_on_error=1"
-        ASAN_OPTIONS: "strict_string_checks=1:detect_stack_use_after_return=1:detect_leaks=1"
-        LSAN_OPTIONS: "use_unaligned=1"
-        SECP256K1_TEST_ITERS: 32
-  # Try to cover many configurations with just a tiny matrix.
-  matrix:
-    - env:
-        ASM: auto
-    - env:
-        ASM: no
-        ECMULTGENPRECISION: 2
-        ECMULTWINDOW: 2
-  matrix:
-    - env:
-        CC: clang
-    - env:
-        HOST: i686-linux-gnu
-        CC: i686-linux-gnu-gcc
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-# Memory sanitizers
-task:
-  << : *LINUX_CONTAINER
-  name: "MSan"
-  env:
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-    CTIMETESTS: yes
-    CC: clang
-    SECP256K1_TEST_ITERS: 32
-    ASM: no
-    WITH_VALGRIND: no
-  container:
-    memory: 2G
-  matrix:
-    - env:
-        CFLAGS: "-fsanitize=memory -g"
-    - env:
-        ECMULTGENPRECISION: 2
-        ECMULTWINDOW: 2
-        CFLAGS: "-fsanitize=memory -g -O3"
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "C++ -fpermissive (entire project)"
-  << : *LINUX_CONTAINER
-  env:
-    CC: g++
-    CFLAGS: -fpermissive -g
-    CPPFLAGS: -DSECP256K1_CPLUSPLUS_TEST_OVERRIDE
-    WERROR_CFLAGS:
-    ECDH: yes
-    RECOVERY: yes
-    SCHNORRSIG: yes
-  << : *MERGE_BASE
-  test_script:
-    - ./ci/cirrus.sh
-  << : *CAT_LOGS
-
-task:
-  name: "C++ (public headers)"
-  << : *LINUX_CONTAINER
-  test_script:
-    - g++ -Werror include/*.h
-    - clang -Werror -x c++-header include/*.h
-    - /opt/msvc/bin/x64/cl.exe -c -WX -TP include/*.h
-
-task:
-  name: "sage prover"
-  << : *LINUX_CONTAINER
-  test_script:
-    - cd sage
-    - sage prove_group_implementations.sage
-
-task:
-  name: "x86_64: Windows (VS 2022)"
-  windows_container:
-    image: cirrusci/windowsservercore:visualstudio2022
-    cpu: 4
-    memory: 3840MB
-  env:
-    PATH: '%CIRRUS_WORKING_DIR%\build\src\RelWithDebInfo;%PATH%'
-    x64_NATIVE_TOOLS: '"C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Auxiliary\Build\vcvars64.bat"'
-    # Ignore MSBuild warning MSB8029.
-    # See: https://learn.microsoft.com/en-us/visualstudio/msbuild/errors/msb8029?view=vs-2022
-    IgnoreWarnIntDirInTempDetected: 'true'
-  merge_script:
-    - PowerShell -NoLogo -Command if ($env:CIRRUS_PR -ne $null) { git fetch $env:CIRRUS_REPO_CLONE_URL pull/$env:CIRRUS_PR/merge; git reset --hard FETCH_HEAD; }
-  configure_script:
-    - '%x64_NATIVE_TOOLS%'
-    - cmake -E env CFLAGS="/WX" cmake -G "Visual Studio 17 2022" -A x64 -S . -B build -DSECP256K1_ENABLE_MODULE_RECOVERY=ON -DSECP256K1_BUILD_EXAMPLES=ON
-  build_script:
-    - '%x64_NATIVE_TOOLS%'
-    - cmake --build build --config RelWithDebInfo -- -property:UseMultiToolTask=true;CL_MPcount=5
-  check_script:
-    - '%x64_NATIVE_TOOLS%'
-    - ctest -C RelWithDebInfo --test-dir build -j 5
-    - build\src\RelWithDebInfo\bench_ecmult.exe
-    - build\src\RelWithDebInfo\bench_internal.exe
-    - build\src\RelWithDebInfo\bench.exe

external/secp256k1/.gitattributes

@@ -1,2 +0,0 @@
-src/precomputed_ecmult.c linguist-generated
-src/precomputed_ecmult_gen.c linguist-generated

external/secp256k1/CHANGELOG.md

@@ -1,93 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.3.2] - 2023-05-13
-We strongly recommend updating to 0.3.2 if you use or plan to use GCC >=13 to compile libsecp256k1. When in doubt, check the GCC version using `gcc -v`.
-
-#### Security
- - Module `ecdh`: Fix "constant-timeness" issue with GCC 13.1 (and potentially future versions of GCC) that could leave applications using libsecp256k1's ECDH module vulnerable to a timing side-channel attack. The fix avoids secret-dependent control flow during ECDH computations when libsecp256k1 is compiled with GCC 13.1.
-
-#### Fixed
- - Fixed an old bug that permitted compilers to potentially output bad assembly code on x86_64. In theory, it could lead to a crash or a read of unrelated memory, but this has never been observed on any compilers so far.
-
-#### Changed
- - Various improvements and changes to CMake builds. CMake builds remain experimental.
-   - Made API versioning consistent with GNU Autotools builds.
-   - Switched to `BUILD_SHARED_LIBS` variable for controlling whether to build a static or a shared library.
-   - Added `SECP256K1_INSTALL` variable for the controlling whether to install the build artefacts.
- - Renamed asm build option `arm` to `arm32`. Use `--with-asm=arm32` instead of `--with-asm=arm` (GNU Autotools), and `-DSECP256K1_ASM=arm32` instead of `-DSECP256K1_ASM=arm` (CMake).
-
-#### ABI Compatibility
-The ABI is compatible with versions 0.3.0 and 0.3.1.
-
-## [0.3.1] - 2023-04-10
-We strongly recommend updating to 0.3.1 if you use or plan to use Clang >=14 to compile libsecp256k1, e.g., Xcode >=14 on macOS has Clang >=14. When in doubt, check the Clang version using `clang -v`.
-
-#### Security
- - Fix "constant-timeness" issue with Clang >=14 that could leave applications using libsecp256k1 vulnerable to a timing side-channel attack. The fix avoids secret-dependent control flow and secret-dependent memory accesses in conditional moves of memory objects when libsecp256k1 is compiled with Clang >=14.
-
-#### Added
-  - Added tests against [Project Wycheproof's](https://github.com/google/wycheproof/) set of ECDSA test vectors (Bitcoin "low-S" variant), a fixed set of test cases designed to trigger various edge cases.
-
-#### Changed
- - Increased minimum required CMake version to 3.13. CMake builds remain experimental.
-
-#### ABI Compatibility
-The ABI is compatible with version 0.3.0.
-
-## [0.3.0] - 2023-03-08
-
-#### Added
- - Added experimental support for CMake builds. Traditional GNU Autotools builds (`./configure` and `make`) remain fully supported.
- - Usage examples: Added a recommended method for securely clearing sensitive data, e.g., secret keys, from memory.
- - Tests: Added a new test binary `noverify_tests`. This binary runs the tests without some additional checks present in the ordinary `tests` binary and is thereby closer to production binaries. The `noverify_tests` binary is automatically run as part of the `make check` target.
-
-#### Fixed
- - Fixed declarations of API variables for MSVC (`__declspec(dllimport)`). This fixes MSVC builds of programs which link against a libsecp256k1 DLL dynamically and use API variables (and not only API functions). Unfortunately, the MSVC linker now will emit warning `LNK4217` when trying to link against libsecp256k1 statically. Pass `/ignore:4217` to the linker to suppress this warning.
-
-#### Changed
- - Forbade cloning or destroying `secp256k1_context_static`. Create a new context instead of cloning the static context. (If this change breaks your code, your code is probably wrong.)
- - Forbade randomizing (copies of) `secp256k1_context_static`. Randomizing a copy of `secp256k1_context_static` did not have any effect and did not provide defense-in-depth protection against side-channel attacks. Create a new context if you want to benefit from randomization.
-
-#### Removed
- - Removed the configuration header `src/libsecp256k1-config.h`. We recommend passing flags to `./configure` or `cmake` to set configuration options (see `./configure --help` or `cmake -LH`). If you cannot or do not want to use one of the supported build systems, pass configuration flags such as `-DSECP256K1_ENABLE_MODULE_SCHNORRSIG` manually to the compiler (see the file `configure.ac` for supported flags).
-
-#### ABI Compatibility
-Due to changes in the API regarding `secp256k1_context_static` described above, the ABI is *not* compatible with previous versions.
-
-## [0.2.0] - 2022-12-12
-
-#### Added
- - Added usage examples for common use cases in a new `examples/` directory.
- - Added `secp256k1_selftest`, to be used in conjunction with `secp256k1_context_static`.
- - Added support for 128-bit wide multiplication on MSVC for x86_64 and arm64, giving roughly a 20% speedup on those platforms.
-
-#### Changed
- - Enabled modules `schnorrsig`, `extrakeys` and `ecdh` by default in `./configure`.
- - The `secp256k1_nonce_function_rfc6979` nonce function, used by default by `secp256k1_ecdsa_sign`, now reduces the message hash modulo the group order to match the specification. This only affects improper use of ECDSA signing API.
-
-#### Deprecated
- - Deprecated context flags `SECP256K1_CONTEXT_VERIFY` and `SECP256K1_CONTEXT_SIGN`. Use `SECP256K1_CONTEXT_NONE` instead.
- - Renamed `secp256k1_context_no_precomp` to `secp256k1_context_static`.
- - Module `schnorrsig`: renamed `secp256k1_schnorrsig_sign` to `secp256k1_schnorrsig_sign32`.
-
-#### ABI Compatibility
-Since this is the first release, we do not compare application binary interfaces.
-However, there are earlier unreleased versions of libsecp256k1 that are *not* ABI compatible with this version.
-
-## [0.1.0] - 2013-03-05 to 2021-12-25
-
-This version was in fact never released.
-The number was given by the build system since the introduction of autotools in Jan 2014 (ea0fe5a5bf0c04f9cc955b2966b614f5f378c6f6).
-Therefore, this version number does not uniquely identify a set of source files.
-
-[unreleased]: https://github.com/bitcoin-core/secp256k1/compare/v0.3.2...HEAD
-[0.3.2]: https://github.com/bitcoin-core/secp256k1/compare/v0.3.1...v0.3.2
-[0.3.1]: https://github.com/bitcoin-core/secp256k1/compare/v0.3.0...v0.3.1
-[0.3.0]: https://github.com/bitcoin-core/secp256k1/compare/v0.2.0...v0.3.0
-[0.2.0]: https://github.com/bitcoin-core/secp256k1/compare/423b6d19d373f1224fd671a982584d7e7900bc93..v0.2.0
-[0.1.0]: https://github.com/bitcoin-core/secp256k1/commit/423b6d19d373f1224fd671a982584d7e7900bc93

external/secp256k1/CMakeLists.txt

@@ -1,331 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-
-if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.15)
-  # MSVC runtime library flags are selected by the CMAKE_MSVC_RUNTIME_LIBRARY abstraction.
-  cmake_policy(SET CMP0091 NEW)
-  # MSVC warning flags are not in CMAKE_<LANG>_FLAGS by default.
-  cmake_policy(SET CMP0092 NEW)
-endif()
-
-project(libsecp256k1
-  # The package (a.k.a. release) version is based on semantic versioning 2.0.0 of
-  # the API. All changes in experimental modules are treated as
-  # backwards-compatible and therefore at most increase the minor version.
-  VERSION 0.3.2
-  DESCRIPTION "Optimized C library for ECDSA signatures and secret/public key operations on curve secp256k1."
-  HOMEPAGE_URL "https://github.com/bitcoin-core/secp256k1"
-  LANGUAGES C
-)
-
-if(CMAKE_VERSION VERSION_LESS 3.21)
-  get_directory_property(parent_directory PARENT_DIRECTORY)
-  if(parent_directory)
-    set(PROJECT_IS_TOP_LEVEL OFF CACHE INTERNAL "Emulates CMake 3.21+ behavior.")
-    set(${PROJECT_NAME}_IS_TOP_LEVEL OFF CACHE INTERNAL "Emulates CMake 3.21+ behavior.")
-  else()
-    set(PROJECT_IS_TOP_LEVEL ON CACHE INTERNAL "Emulates CMake 3.21+ behavior.")
-    set(${PROJECT_NAME}_IS_TOP_LEVEL ON CACHE INTERNAL "Emulates CMake 3.21+ behavior.")
-  endif()
-  unset(parent_directory)
-endif()
-
-# The library version is based on libtool versioning of the ABI. The set of
-# rules for updating the version can be found here:
-# https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
-# All changes in experimental modules are treated as if they don't affect the
-# interface and therefore only increase the revision.
-set(${PROJECT_NAME}_LIB_VERSION_CURRENT 2)
-set(${PROJECT_NAME}_LIB_VERSION_REVISION 2)
-set(${PROJECT_NAME}_LIB_VERSION_AGE 0)
-
-set(CMAKE_C_STANDARD 90)
-set(CMAKE_C_EXTENSIONS OFF)
-
-list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
-
-option(BUILD_SHARED_LIBS "Build shared libraries." ON)
-option(SECP256K1_DISABLE_SHARED "Disable shared library. Overrides BUILD_SHARED_LIBS." OFF)
-if(SECP256K1_DISABLE_SHARED)
-  set(BUILD_SHARED_LIBS OFF)
-endif()
-
-option(SECP256K1_INSTALL "Enable installation." ${PROJECT_IS_TOP_LEVEL})
-
-option(SECP256K1_ENABLE_MODULE_ECDH "Enable ECDH module." ON)
-if(SECP256K1_ENABLE_MODULE_ECDH)
-  add_compile_definitions(ENABLE_MODULE_ECDH=1)
-endif()
-
-option(SECP256K1_ENABLE_MODULE_RECOVERY "Enable ECDSA pubkey recovery module." OFF)
-if(SECP256K1_ENABLE_MODULE_RECOVERY)
-  add_compile_definitions(ENABLE_MODULE_RECOVERY=1)
-endif()
-
-option(SECP256K1_ENABLE_MODULE_EXTRAKEYS "Enable extrakeys module." ON)
-option(SECP256K1_ENABLE_MODULE_SCHNORRSIG "Enable schnorrsig module." ON)
-if(SECP256K1_ENABLE_MODULE_SCHNORRSIG)
-  set(SECP256K1_ENABLE_MODULE_EXTRAKEYS ON)
-  add_compile_definitions(ENABLE_MODULE_SCHNORRSIG=1)
-endif()
-if(SECP256K1_ENABLE_MODULE_EXTRAKEYS)
-  add_compile_definitions(ENABLE_MODULE_EXTRAKEYS=1)
-endif()
-
-option(SECP256K1_USE_EXTERNAL_DEFAULT_CALLBACKS "Enable external default callback functions." OFF)
-if(SECP256K1_USE_EXTERNAL_DEFAULT_CALLBACKS)
-  add_compile_definitions(USE_EXTERNAL_DEFAULT_CALLBACKS=1)
-endif()
-
-set(SECP256K1_ECMULT_WINDOW_SIZE "AUTO" CACHE STRING "Window size for ecmult precomputation for verification, specified as integer in range [2..24]. \"AUTO\" is a reasonable setting for desktop machines (currently 15). [default=AUTO]")
-set_property(CACHE SECP256K1_ECMULT_WINDOW_SIZE PROPERTY STRINGS "AUTO" 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24)
-include(CheckStringOptionValue)
-check_string_option_value(SECP256K1_ECMULT_WINDOW_SIZE)
-if(SECP256K1_ECMULT_WINDOW_SIZE STREQUAL "AUTO")
-  set(SECP256K1_ECMULT_WINDOW_SIZE 15)
-endif()
-add_compile_definitions(ECMULT_WINDOW_SIZE=${SECP256K1_ECMULT_WINDOW_SIZE})
-
-set(SECP256K1_ECMULT_GEN_PREC_BITS "AUTO" CACHE STRING "Precision bits to tune the precomputed table size for signing, specified as integer 2, 4 or 8. \"AUTO\" is a reasonable setting for desktop machines (currently 4). [default=AUTO]")
-set_property(CACHE SECP256K1_ECMULT_GEN_PREC_BITS PROPERTY STRINGS "AUTO" 2 4 8)
-check_string_option_value(SECP256K1_ECMULT_GEN_PREC_BITS)
-if(SECP256K1_ECMULT_GEN_PREC_BITS STREQUAL "AUTO")
-  set(SECP256K1_ECMULT_GEN_PREC_BITS 4)
-endif()
-add_compile_definitions(ECMULT_GEN_PREC_BITS=${SECP256K1_ECMULT_GEN_PREC_BITS})
-
-set(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY "OFF" CACHE STRING "Test-only override of the (autodetected by the C code) \"widemul\" setting. Legal values are: \"OFF\", \"int128_struct\", \"int128\" or \"int64\". [default=OFF]")
-set_property(CACHE SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY PROPERTY STRINGS "OFF" "int128_struct" "int128" "int64")
-check_string_option_value(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY)
-if(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY)
-  string(TOUPPER "${SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY}" widemul_upper_value)
-  add_compile_definitions(USE_FORCE_WIDEMUL_${widemul_upper_value}=1)
-endif()
-mark_as_advanced(FORCE SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY)
-
-set(SECP256K1_ASM "AUTO" CACHE STRING "Assembly optimizations to use: \"AUTO\", \"OFF\", \"x86_64\" or \"arm32\" (experimental). [default=AUTO]")
-set_property(CACHE SECP256K1_ASM PROPERTY STRINGS "AUTO" "OFF" "x86_64" "arm32")
-check_string_option_value(SECP256K1_ASM)
-if(SECP256K1_ASM STREQUAL "arm32")
-  enable_language(ASM)
-  include(CheckArm32Assembly)
-  check_arm32_assembly()
-  if(HAVE_ARM32_ASM)
-    add_compile_definitions(USE_EXTERNAL_ASM=1)
-  else()
-    message(FATAL_ERROR "ARM32 assembly optimization requested but not available.")
-  endif()
-elseif(SECP256K1_ASM)
-  include(CheckX86_64Assembly)
-  check_x86_64_assembly()
-  if(HAVE_X86_64_ASM)
-    set(SECP256K1_ASM "x86_64")
-    add_compile_definitions(USE_ASM_X86_64=1)
-  elseif(SECP256K1_ASM STREQUAL "AUTO")
-    set(SECP256K1_ASM "OFF")
-  else()
-    message(FATAL_ERROR "x86_64 assembly optimization requested but not available.")
-  endif()
-endif()
-
-option(SECP256K1_EXPERIMENTAL "Allow experimental configuration options." OFF)
-if(NOT SECP256K1_EXPERIMENTAL)
-  if(SECP256K1_ASM STREQUAL "arm32")
-    message(FATAL_ERROR "ARM32 assembly optimization is experimental. Use -DSECP256K1_EXPERIMENTAL=ON to allow.")
-  endif()
-endif()
-
-set(SECP256K1_VALGRIND "AUTO" CACHE STRING "Build with extra checks for running inside Valgrind. [default=AUTO]")
-set_property(CACHE SECP256K1_VALGRIND PROPERTY STRINGS "AUTO" "OFF" "ON")
-check_string_option_value(SECP256K1_VALGRIND)
-if(SECP256K1_VALGRIND)
-  find_package(Valgrind MODULE)
-  if(Valgrind_FOUND)
-    set(SECP256K1_VALGRIND ON)
-    include_directories(${Valgrind_INCLUDE_DIR})
-    add_compile_definitions(VALGRIND)
-  elseif(SECP256K1_VALGRIND STREQUAL "AUTO")
-    set(SECP256K1_VALGRIND OFF)
-  else()
-    message(FATAL_ERROR "Valgrind support requested but valgrind/memcheck.h header not available.")
-  endif()
-endif()
-
-option(SECP256K1_BUILD_BENCHMARK "Build benchmarks." ON)
-option(SECP256K1_BUILD_TESTS "Build tests." ON)
-option(SECP256K1_BUILD_EXHAUSTIVE_TESTS "Build exhaustive tests." ON)
-option(SECP256K1_BUILD_CTIME_TESTS "Build constant-time tests." ${SECP256K1_VALGRIND})
-option(SECP256K1_BUILD_EXAMPLES "Build examples." OFF)
-
-# Redefine configuration flags.
-# We leave assertions on, because they are only used in the examples, and we want them always on there.
-if(MSVC)
-  string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-  string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
-  string(REGEX REPLACE "/DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
-else()
-  string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-  string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
-  string(REGEX REPLACE "-DNDEBUG[ \t\r\n]*" "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
-  # Prefer -O2 optimization level. (-O3 is CMake's default for Release for many compilers.)
-  string(REGEX REPLACE "-O3[ \t\r\n]*" "-O2" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
-endif()
-
-# Define custom "Coverage" build type.
-set(CMAKE_C_FLAGS_COVERAGE "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O0 -DCOVERAGE=1 --coverage" CACHE STRING
-  "Flags used by the C compiler during \"Coverage\" builds."
-  FORCE
-)
-set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} --coverage" CACHE STRING
-  "Flags used for linking binaries during \"Coverage\" builds."
-  FORCE
-)
-set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} --coverage" CACHE STRING
-  "Flags used by the shared libraries linker during \"Coverage\" builds."
-  FORCE
-)
-mark_as_advanced(
-  CMAKE_C_FLAGS_COVERAGE
-  CMAKE_EXE_LINKER_FLAGS_COVERAGE
-  CMAKE_SHARED_LINKER_FLAGS_COVERAGE
-)
-
-get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-set(default_build_type "RelWithDebInfo")
-if(is_multi_config)
-  set(CMAKE_CONFIGURATION_TYPES "${default_build_type}" "Release" "Debug" "MinSizeRel" "Coverage" CACHE STRING
-    "Supported configuration types."
-    FORCE
-  )
-else()
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
-    STRINGS "${default_build_type}" "Release" "Debug" "MinSizeRel" "Coverage"
-  )
-  if(NOT CMAKE_BUILD_TYPE)
-    message(STATUS "Setting build type to \"${default_build_type}\" as none was specified")
-    set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE STRING
-      "Choose the type of build."
-      FORCE
-    )
-  endif()
-endif()
-
-include(TryAppendCFlags)
-if(MSVC)
-  # Keep the following commands ordered lexicographically.
-  try_append_c_flags(/W2) # Moderate warning level.
-  try_append_c_flags(/wd4146) # Disable warning C4146 "unary minus operator applied to unsigned type, result still unsigned".
-else()
-  # Keep the following commands ordered lexicographically.
-  try_append_c_flags(-pedantic)
-  try_append_c_flags(-Wall) # GCC >= 2.95 and probably many other compilers.
-  try_append_c_flags(-Wcast-align) # GCC >= 2.95.
-  try_append_c_flags(-Wcast-align=strict) # GCC >= 8.0.
-  try_append_c_flags(-Wconditional-uninitialized) # Clang >= 3.0 only.
-  try_append_c_flags(-Wextra) # GCC >= 3.4, this is the newer name of -W, which we don't use because older GCCs will warn about unused functions.
-  try_append_c_flags(-Wnested-externs)
-  try_append_c_flags(-Wno-long-long) # GCC >= 3.0, -Wlong-long is implied by -pedantic.
-  try_append_c_flags(-Wno-overlength-strings) # GCC >= 4.2, -Woverlength-strings is implied by -pedantic.
-  try_append_c_flags(-Wno-unused-function) # GCC >= 3.0, -Wunused-function is implied by -Wall.
-  try_append_c_flags(-Wreserved-identifier) # Clang >= 13.0 only.
-  try_append_c_flags(-Wshadow)
-  try_append_c_flags(-Wstrict-prototypes)
-  try_append_c_flags(-Wundef)
-endif()
-
-set(CMAKE_C_VISIBILITY_PRESET hidden)
-
-# Ask CTest to create a "check" target (e.g., make check) as alias for the "test" target.
-# CTEST_TEST_TARGET_ALIAS is not documented but supposed to be user-facing.
-# See: https://gitlab.kitware.com/cmake/cmake/-/commit/816c9d1aa1f2b42d40c81a991b68c96eb12b6d2
-set(CTEST_TEST_TARGET_ALIAS check)
-include(CTest)
-# We do not use CTest's BUILD_TESTING because a single toggle for all tests is too coarse for our needs.
-mark_as_advanced(BUILD_TESTING)
-if(SECP256K1_BUILD_BENCHMARK OR SECP256K1_BUILD_TESTS OR SECP256K1_BUILD_EXHAUSTIVE_TESTS OR SECP256K1_BUILD_CTIME_TESTS OR SECP256K1_BUILD_EXAMPLES)
-  enable_testing()
-endif()
-
-add_subdirectory(src)
-if(SECP256K1_BUILD_EXAMPLES)
-  add_subdirectory(examples)
-endif()
-
-message("\n")
-message("secp256k1 configure summary")
-message("===========================")
-message("Build artifacts:")
-if(BUILD_SHARED_LIBS)
-  set(library_type "Shared")
-else()
-  set(library_type "Static")
-endif()
-
-message("  library type ........................ ${library_type}")
-message("Optional modules:")
-message("  ECDH ................................ ${SECP256K1_ENABLE_MODULE_ECDH}")
-message("  ECDSA pubkey recovery ............... ${SECP256K1_ENABLE_MODULE_RECOVERY}")
-message("  extrakeys ........................... ${SECP256K1_ENABLE_MODULE_EXTRAKEYS}")
-message("  schnorrsig .......................... ${SECP256K1_ENABLE_MODULE_SCHNORRSIG}")
-message("Parameters:")
-message("  ecmult window size .................. ${SECP256K1_ECMULT_WINDOW_SIZE}")
-message("  ecmult gen precision bits ........... ${SECP256K1_ECMULT_GEN_PREC_BITS}")
-message("Optional features:")
-message("  assembly optimization ............... ${SECP256K1_ASM}")
-message("  external callbacks .................. ${SECP256K1_USE_EXTERNAL_DEFAULT_CALLBACKS}")
-if(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY)
-  message("  wide multiplication (test-only) ..... ${SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY}")
-endif()
-message("Optional binaries:")
-message("  benchmark ........................... ${SECP256K1_BUILD_BENCHMARK}")
-message("  noverify_tests ...................... ${SECP256K1_BUILD_TESTS}")
-set(tests_status "${SECP256K1_BUILD_TESTS}")
-if(CMAKE_BUILD_TYPE STREQUAL "Coverage")
-  set(tests_status OFF)
-endif()
-message("  tests ............................... ${tests_status}")
-message("  exhaustive tests .................... ${SECP256K1_BUILD_EXHAUSTIVE_TESTS}")
-message("  ctime_tests ......................... ${SECP256K1_BUILD_CTIME_TESTS}")
-message("  examples ............................ ${SECP256K1_BUILD_EXAMPLES}")
-message("")
-if(CMAKE_CROSSCOMPILING)
-  set(cross_status "TRUE, for ${CMAKE_SYSTEM_NAME}, ${CMAKE_SYSTEM_PROCESSOR}")
-else()
-  set(cross_status "FALSE")
-endif()
-message("Cross compiling ....................... ${cross_status}")
-message("Valgrind .............................. ${SECP256K1_VALGRIND}")
-get_directory_property(definitions COMPILE_DEFINITIONS)
-string(REPLACE ";" " " definitions "${definitions}")
-message("Preprocessor defined macros ........... ${definitions}")
-message("C compiler ............................ ${CMAKE_C_COMPILER}")
-message("CFLAGS ................................ ${CMAKE_C_FLAGS}")
-get_directory_property(compile_options COMPILE_OPTIONS)
-string(REPLACE ";" " " compile_options "${compile_options}")
-message("Compile options ....................... " ${compile_options})
-if(NOT is_multi_config)
-  message("Build type:")
-  message(" - CMAKE_BUILD_TYPE ................... ${CMAKE_BUILD_TYPE}")
-  string(TOUPPER "${CMAKE_BUILD_TYPE}" build_type)
-  message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_${build_type}}")
-  message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_${build_type}}")
-  message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_${build_type}}")
-else()
-  message("Supported configurations .............. ${CMAKE_CONFIGURATION_TYPES}")
-  message("RelWithDebInfo configuration:")
-  message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-  message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO}")
-  message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO}")
-  message("Debug configuration:")
-  message(" - CFLAGS ............................. ${CMAKE_C_FLAGS_DEBUG}")
-  message(" - LDFLAGS for executables ............ ${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
-  message(" - LDFLAGS for shared libraries ....... ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
-endif()
-message("\n")
-if(SECP256K1_EXPERIMENTAL)
-  message(
-    "  ******\n"
-    "  WARNING: experimental build\n"
-    "  Experimental features do not have stable APIs or properties, and may not be safe for production use.\n"
-    "  ******\n"
-  )
-endif()

external/secp256k1/CMakePresets.json

@@ -1,19 +0,0 @@
-{
-  "cmakeMinimumRequired": {"major": 3, "minor": 21, "patch": 0}, 
-  "version": 3,
-  "configurePresets": [
-    {
-      "name": "dev-mode",
-      "displayName": "Development mode (intended only for developers of the library)",
-      "cacheVariables": {
-        "SECP256K1_EXPERIMENTAL": "ON",
-        "SECP256K1_ENABLE_MODULE_RECOVERY": "ON",
-        "SECP256K1_BUILD_EXAMPLES": "ON"
-      },
-      "warnings": {
-        "dev": true,
-        "uninitialized": true
-      }
-    }
-  ]
-}

external/secp256k1/Makefile.am

@@ -1,269 +0,0 @@
-ACLOCAL_AMFLAGS = -I build-aux/m4
-
-# AM_CFLAGS will be automatically prepended to CFLAGS by Automake when compiling some foo
-# which does not have an explicit foo_CFLAGS variable set.
-AM_CFLAGS = $(SECP_CFLAGS)
-
-lib_LTLIBRARIES = libsecp256k1.la
-include_HEADERS = include/secp256k1.h
-include_HEADERS += include/secp256k1_preallocated.h
-noinst_HEADERS =
-noinst_HEADERS += src/scalar.h
-noinst_HEADERS += src/scalar_4x64.h
-noinst_HEADERS += src/scalar_8x32.h
-noinst_HEADERS += src/scalar_low.h
-noinst_HEADERS += src/scalar_impl.h
-noinst_HEADERS += src/scalar_4x64_impl.h
-noinst_HEADERS += src/scalar_8x32_impl.h
-noinst_HEADERS += src/scalar_low_impl.h
-noinst_HEADERS += src/group.h
-noinst_HEADERS += src/group_impl.h
-noinst_HEADERS += src/ecdsa.h
-noinst_HEADERS += src/ecdsa_impl.h
-noinst_HEADERS += src/eckey.h
-noinst_HEADERS += src/eckey_impl.h
-noinst_HEADERS += src/ecmult.h
-noinst_HEADERS += src/ecmult_impl.h
-noinst_HEADERS += src/ecmult_compute_table.h
-noinst_HEADERS += src/ecmult_compute_table_impl.h
-noinst_HEADERS += src/ecmult_const.h
-noinst_HEADERS += src/ecmult_const_impl.h
-noinst_HEADERS += src/ecmult_gen.h
-noinst_HEADERS += src/ecmult_gen_impl.h
-noinst_HEADERS += src/ecmult_gen_compute_table.h
-noinst_HEADERS += src/ecmult_gen_compute_table_impl.h
-noinst_HEADERS += src/field_10x26.h
-noinst_HEADERS += src/field_10x26_impl.h
-noinst_HEADERS += src/field_5x52.h
-noinst_HEADERS += src/field_5x52_impl.h
-noinst_HEADERS += src/field_5x52_int128_impl.h
-noinst_HEADERS += src/field_5x52_asm_impl.h
-noinst_HEADERS += src/modinv32.h
-noinst_HEADERS += src/modinv32_impl.h
-noinst_HEADERS += src/modinv64.h
-noinst_HEADERS += src/modinv64_impl.h
-noinst_HEADERS += src/precomputed_ecmult.h
-noinst_HEADERS += src/precomputed_ecmult_gen.h
-noinst_HEADERS += src/assumptions.h
-noinst_HEADERS += src/checkmem.h
-noinst_HEADERS += src/util.h
-noinst_HEADERS += src/int128.h
-noinst_HEADERS += src/int128_impl.h
-noinst_HEADERS += src/int128_native.h
-noinst_HEADERS += src/int128_native_impl.h
-noinst_HEADERS += src/int128_struct.h
-noinst_HEADERS += src/int128_struct_impl.h
-noinst_HEADERS += src/scratch.h
-noinst_HEADERS += src/scratch_impl.h
-noinst_HEADERS += src/selftest.h
-noinst_HEADERS += src/testrand.h
-noinst_HEADERS += src/testrand_impl.h
-noinst_HEADERS += src/hash.h
-noinst_HEADERS += src/hash_impl.h
-noinst_HEADERS += src/field.h
-noinst_HEADERS += src/field_impl.h
-noinst_HEADERS += src/bench.h
-noinst_HEADERS += src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.h
-noinst_HEADERS += contrib/lax_der_parsing.h
-noinst_HEADERS += contrib/lax_der_parsing.c
-noinst_HEADERS += contrib/lax_der_privatekey_parsing.h
-noinst_HEADERS += contrib/lax_der_privatekey_parsing.c
-noinst_HEADERS += examples/examples_util.h
-
-PRECOMPUTED_LIB = libsecp256k1_precomputed.la
-noinst_LTLIBRARIES = $(PRECOMPUTED_LIB)
-libsecp256k1_precomputed_la_SOURCES =  src/precomputed_ecmult.c src/precomputed_ecmult_gen.c
-# We need `-I$(top_srcdir)/src` in VPATH builds if libsecp256k1_precomputed_la_SOURCES have been recreated in the build tree.
-# This helps users and packagers who insist on recreating the precomputed files (e.g., Gentoo).
-libsecp256k1_precomputed_la_CPPFLAGS = -I$(top_srcdir)/src $(SECP_CONFIG_DEFINES)
-
-if USE_EXTERNAL_ASM
-COMMON_LIB = libsecp256k1_common.la
-else
-COMMON_LIB =
-endif
-noinst_LTLIBRARIES += $(COMMON_LIB)
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = libsecp256k1.pc
-
-if USE_EXTERNAL_ASM
-if USE_ASM_ARM
-libsecp256k1_common_la_SOURCES = src/asm/field_10x26_arm.s
-endif
-endif
-
-libsecp256k1_la_SOURCES = src/secp256k1.c
-libsecp256k1_la_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-libsecp256k1_la_LIBADD = $(COMMON_LIB) $(PRECOMPUTED_LIB)
-libsecp256k1_la_LDFLAGS = -no-undefined -version-info $(LIB_VERSION_CURRENT):$(LIB_VERSION_REVISION):$(LIB_VERSION_AGE)
-
-noinst_PROGRAMS =
-if USE_BENCHMARK
-noinst_PROGRAMS += bench bench_internal bench_ecmult
-bench_SOURCES = src/bench.c
-bench_LDADD = libsecp256k1.la
-bench_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-bench_internal_SOURCES = src/bench_internal.c
-bench_internal_LDADD = $(COMMON_LIB) $(PRECOMPUTED_LIB)
-bench_internal_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-bench_ecmult_SOURCES = src/bench_ecmult.c
-bench_ecmult_LDADD = $(COMMON_LIB) $(PRECOMPUTED_LIB)
-bench_ecmult_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-endif
-
-TESTS =
-if USE_TESTS
-TESTS += noverify_tests
-noinst_PROGRAMS += noverify_tests
-noverify_tests_SOURCES = src/tests.c
-noverify_tests_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-noverify_tests_LDADD = $(COMMON_LIB) $(PRECOMPUTED_LIB)
-noverify_tests_LDFLAGS = -static
-if !ENABLE_COVERAGE
-TESTS += tests
-noinst_PROGRAMS += tests
-tests_SOURCES  = $(noverify_tests_SOURCES)
-tests_CPPFLAGS = $(noverify_tests_CPPFLAGS) -DVERIFY
-tests_LDADD    = $(noverify_tests_LDADD)
-tests_LDFLAGS  = $(noverify_tests_LDFLAGS)
-endif
-endif
-
-if USE_CTIME_TESTS
-noinst_PROGRAMS += ctime_tests
-ctime_tests_SOURCES = src/ctime_tests.c
-ctime_tests_LDADD = libsecp256k1.la
-ctime_tests_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-endif
-
-if USE_EXHAUSTIVE_TESTS
-noinst_PROGRAMS += exhaustive_tests
-exhaustive_tests_SOURCES = src/tests_exhaustive.c
-exhaustive_tests_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-if !ENABLE_COVERAGE
-exhaustive_tests_CPPFLAGS += -DVERIFY
-endif
-# Note: do not include $(PRECOMPUTED_LIB) in exhaustive_tests (it uses runtime-generated tables).
-exhaustive_tests_LDADD = $(COMMON_LIB)
-exhaustive_tests_LDFLAGS = -static
-TESTS += exhaustive_tests
-endif
-
-if USE_EXAMPLES
-noinst_PROGRAMS += ecdsa_example
-ecdsa_example_SOURCES = examples/ecdsa.c
-ecdsa_example_CPPFLAGS = -I$(top_srcdir)/include
-ecdsa_example_LDADD = libsecp256k1.la
-ecdsa_example_LDFLAGS = -static
-if BUILD_WINDOWS
-ecdsa_example_LDFLAGS += -lbcrypt
-endif
-TESTS += ecdsa_example
-if ENABLE_MODULE_ECDH
-noinst_PROGRAMS += ecdh_example
-ecdh_example_SOURCES = examples/ecdh.c
-ecdh_example_CPPFLAGS = -I$(top_srcdir)/include
-ecdh_example_LDADD = libsecp256k1.la
-ecdh_example_LDFLAGS = -static
-if BUILD_WINDOWS
-ecdh_example_LDFLAGS += -lbcrypt
-endif
-TESTS += ecdh_example
-endif
-if ENABLE_MODULE_SCHNORRSIG
-noinst_PROGRAMS += schnorr_example
-schnorr_example_SOURCES = examples/schnorr.c
-schnorr_example_CPPFLAGS = -I$(top_srcdir)/include
-schnorr_example_LDADD = libsecp256k1.la
-schnorr_example_LDFLAGS = -static
-if BUILD_WINDOWS
-schnorr_example_LDFLAGS += -lbcrypt
-endif
-TESTS += schnorr_example
-endif
-endif
-
-### Precomputed tables
-EXTRA_PROGRAMS = precompute_ecmult precompute_ecmult_gen
-CLEANFILES = $(EXTRA_PROGRAMS)
-
-precompute_ecmult_SOURCES = src/precompute_ecmult.c
-precompute_ecmult_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-precompute_ecmult_LDADD = $(COMMON_LIB)
-
-precompute_ecmult_gen_SOURCES = src/precompute_ecmult_gen.c
-precompute_ecmult_gen_CPPFLAGS = $(SECP_CONFIG_DEFINES)
-precompute_ecmult_gen_LDADD = $(COMMON_LIB)
-
-# See Automake manual, Section "Errors with distclean".
-# We don't list any dependencies for the prebuilt files here because
-# otherwise make's decision whether to rebuild them (even in the first
-# build by a normal user) depends on mtimes, and thus is very fragile.
-# This means that rebuilds of the prebuilt files always need to be
-# forced by deleting them.
-src/precomputed_ecmult.c:
-	$(MAKE) $(AM_MAKEFLAGS) precompute_ecmult$(EXEEXT)
-	./precompute_ecmult$(EXEEXT)
-src/precomputed_ecmult_gen.c:
-	$(MAKE) $(AM_MAKEFLAGS) precompute_ecmult_gen$(EXEEXT)
-	./precompute_ecmult_gen$(EXEEXT)
-
-PRECOMP = src/precomputed_ecmult_gen.c src/precomputed_ecmult.c
-precomp: $(PRECOMP)
-
-# Ensure the prebuilt files will be build first (only if they don't exist,
-# e.g., after `make maintainer-clean`).
-BUILT_SOURCES = $(PRECOMP)
-
-.PHONY: clean-precomp
-clean-precomp:
-	rm -f $(PRECOMP)
-maintainer-clean-local: clean-precomp
-
-### Pregenerated test vectors
-### (see the comments in the previous section for detailed rationale)
-TESTVECTORS = src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.h
-
-src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.h:
-	mkdir -p $(@D)
-	python3 $(top_srcdir)/tools/tests_wycheproof_generate.py $(top_srcdir)/src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.json > $@
-
-testvectors: $(TESTVECTORS)
-
-BUILT_SOURCES += $(TESTVECTORS)
-
-.PHONY: clean-testvectors
-clean-testvectors:
-	rm -f $(TESTVECTORS)
-maintainer-clean-local: clean-testvectors
-
-### Additional files to distribute
-EXTRA_DIST = autogen.sh CHANGELOG.md SECURITY.md
-EXTRA_DIST += doc/release-process.md doc/safegcd_implementation.md
-EXTRA_DIST += examples/EXAMPLES_COPYING
-EXTRA_DIST += sage/gen_exhaustive_groups.sage
-EXTRA_DIST += sage/gen_split_lambda_constants.sage
-EXTRA_DIST += sage/group_prover.sage
-EXTRA_DIST += sage/prove_group_implementations.sage
-EXTRA_DIST += sage/secp256k1_params.sage
-EXTRA_DIST += sage/weierstrass_prover.sage
-EXTRA_DIST += src/wycheproof/WYCHEPROOF_COPYING
-EXTRA_DIST += src/wycheproof/ecdsa_secp256k1_sha256_bitcoin_test.json
-EXTRA_DIST += tools/tests_wycheproof_generate.py
-
-if ENABLE_MODULE_ECDH
-include src/modules/ecdh/Makefile.am.include
-endif
-
-if ENABLE_MODULE_RECOVERY
-include src/modules/recovery/Makefile.am.include
-endif
-
-if ENABLE_MODULE_EXTRAKEYS
-include src/modules/extrakeys/Makefile.am.include
-endif
-
-if ENABLE_MODULE_SCHNORRSIG
-include src/modules/schnorrsig/Makefile.am.include
-endif

external/secp256k1/README.md

@@ -1,157 +0,0 @@
-libsecp256k1
-============
-
-[![Build Status](https://api.cirrus-ci.com/github/bitcoin-core/secp256k1.svg?branch=master)](https://cirrus-ci.com/github/bitcoin-core/secp256k1)
-![Dependencies: None](https://img.shields.io/badge/dependencies-none-success)
-[![irc.libera.chat #secp256k1](https://img.shields.io/badge/irc.libera.chat-%23secp256k1-success)](https://web.libera.chat/#secp256k1)
-
-Optimized C library for ECDSA signatures and secret/public key operations on curve secp256k1.
-
-This library is intended to be the highest quality publicly available library for cryptography on the secp256k1 curve. However, the primary focus of its development has been for usage in the Bitcoin system and usage unlike Bitcoin's may be less well tested, verified, or suffer from a less well thought out interface. Correct usage requires some care and consideration that the library is fit for your application's purpose.
-
-Features:
-* secp256k1 ECDSA signing/verification and key generation.
-* Additive and multiplicative tweaking of secret/public keys.
-* Serialization/parsing of secret keys, public keys, signatures.
-* Constant time, constant memory access signing and public key generation.
-* Derandomized ECDSA (via RFC6979 or with a caller provided function.)
-* Very efficient implementation.
-* Suitable for embedded systems.
-* No runtime dependencies.
-* Optional module for public key recovery.
-* Optional module for ECDH key exchange.
-* Optional module for Schnorr signatures according to [BIP-340](https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki).
-
-Implementation details
-----------------------
-
-* General
-  * No runtime heap allocation.
-  * Extensive testing infrastructure.
-  * Structured to facilitate review and analysis.
-  * Intended to be portable to any system with a C89 compiler and uint64_t support.
-  * No use of floating types.
-  * Expose only higher level interfaces to minimize the API surface and improve application security. ("Be difficult to use insecurely.")
-* Field operations
-  * Optimized implementation of arithmetic modulo the curve's field size (2^256 - 0x1000003D1).
-    * Using 5 52-bit limbs (including hand-optimized assembly for x86_64, by Diederik Huys).
-    * Using 10 26-bit limbs (including hand-optimized assembly for 32-bit ARM, by Wladimir J. van der Laan).
-      * This is an experimental feature that has not received enough scrutiny to satisfy the standard of quality of this library but is made available for testing and review by the community.
-* Scalar operations
-  * Optimized implementation without data-dependent branches of arithmetic modulo the curve's order.
-    * Using 4 64-bit limbs (relying on __int128 support in the compiler).
-    * Using 8 32-bit limbs.
-* Modular inverses (both field elements and scalars) based on [safegcd](https://gcd.cr.yp.to/index.html) with some modifications, and a variable-time variant (by Peter Dettman).
-* Group operations
-  * Point addition formula specifically simplified for the curve equation (y^2 = x^3 + 7).
-  * Use addition between points in Jacobian and affine coordinates where possible.
-  * Use a unified addition/doubling formula where necessary to avoid data-dependent branches.
-  * Point/x comparison without a field inversion by comparison in the Jacobian coordinate space.
-* Point multiplication for verification (a*P + b*G).
-  * Use wNAF notation for point multiplicands.
-  * Use a much larger window for multiples of G, using precomputed multiples.
-  * Use Shamir's trick to do the multiplication with the public key and the generator simultaneously.
-  * Use secp256k1's efficiently-computable endomorphism to split the P multiplicand into 2 half-sized ones.
-* Point multiplication for signing
-  * Use a precomputed table of multiples of powers of 16 multiplied with the generator, so general multiplication becomes a series of additions.
-  * Intended to be completely free of timing sidechannels for secret-key operations (on reasonable hardware/toolchains)
-    * Access the table with branch-free conditional moves so memory access is uniform.
-    * No data-dependent branches
-  * Optional runtime blinding which attempts to frustrate differential power analysis.
-  * The precomputed tables add and eventually subtract points for which no known scalar (secret key) is known, preventing even an attacker with control over the secret key used to control the data internally.
-
-Building with Autotools
------------------------
-
-    $ ./autogen.sh
-    $ ./configure
-    $ make
-    $ make check  # run the test suite
-    $ sudo make install  # optional
-
-To compile optional modules (such as Schnorr signatures), you need to run `./configure` with additional flags (such as `--enable-module-schnorrsig`). Run `./configure --help` to see the full list of available flags.
-
-Building with CMake (experimental)
-----------------------------------
-
-To maintain a pristine source tree, CMake encourages to perform an out-of-source build by using a separate dedicated build tree.
-
-### Building on POSIX systems
-
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make
-    $ make check  # run the test suite
-    $ sudo make install  # optional
-
-To compile optional modules (such as Schnorr signatures), you need to run `cmake` with additional flags (such as `-DSECP256K1_ENABLE_MODULE_SCHNORRSIG=ON`). Run `cmake .. -LH` to see the full list of available flags.
-
-### Cross compiling
-
-To alleviate issues with cross compiling, preconfigured toolchain files are available in the `cmake` directory.
-For example, to cross compile for Windows:
-
-    $ cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/x86_64-w64-mingw32.toolchain.cmake
-
-To cross compile for Android with [NDK](https://developer.android.com/ndk/guides/cmake) (using NDK's toolchain file, and assuming the `ANDROID_NDK_ROOT` environment variable has been set):
-
-    $ cmake .. -DCMAKE_TOOLCHAIN_FILE="${ANDROID_NDK_ROOT}/build/cmake/android.toolchain.cmake" -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=28
-
-### Building on Windows
-
-To build on Windows with Visual Studio, a proper [generator](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html#visual-studio-generators) must be specified for a new build tree.
-
-The following example assumes using of Visual Studio 2022 and CMake v3.21+.
-
-In "Developer Command Prompt for VS 2022":
-
-    >cmake -G "Visual Studio 17 2022" -A x64 -S . -B build
-    >cmake --build build --config RelWithDebInfo
-
-Usage examples
------------
-Usage examples can be found in the [examples](examples) directory. To compile them you need to configure with `--enable-examples`.
-  * [ECDSA example](examples/ecdsa.c)
-  * [Schnorr signatures example](examples/schnorr.c)
-  * [Deriving a shared secret (ECDH) example](examples/ecdh.c)
-
-To compile the Schnorr signature and ECDH examples, you also need to configure with `--enable-module-schnorrsig` and `--enable-module-ecdh`.
-
-Test coverage
------------
-
-This library aims to have full coverage of the reachable lines and branches.
-
-To create a test coverage report, configure with `--enable-coverage` (use of GCC is necessary):
-
-    $ ./configure --enable-coverage
-
-Run the tests:
-
-    $ make check
-
-To create a report, `gcovr` is recommended, as it includes branch coverage reporting:
-
-    $ gcovr --exclude 'src/bench*' --print-summary
-
-To create a HTML report with coloured and annotated source code:
-
-    $ mkdir -p coverage
-    $ gcovr --exclude 'src/bench*' --html --html-details -o coverage/coverage.html
-
-Benchmark
-------------
-If configured with `--enable-benchmark` (which is the default), binaries for benchmarking the libsecp256k1 functions will be present in the root directory after the build.
-
-To print the benchmark result to the command line:
-
-    $ ./bench_name
-
-To create a CSV file for the benchmark result :
-
-    $ ./bench_name | sed '2d;s/ \{1,\}//g' > bench_name.csv
-
-Reporting a vulnerability
-------------
-
-See [SECURITY.md](SECURITY.md)

external/secp256k1/SECURITY.md

@@ -1,15 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-To report security issues send an email to secp256k1-security@bitcoincore.org (not for support).
-
-The following keys may be used to communicate sensitive information to developers:
-
-| Name | Fingerprint |
-|------|-------------|
-| Pieter Wuille | 133E AC17 9436 F14A 5CF1  B794 860F EB80 4E66 9320 |
-| Jonas Nick | 36C7 1A37 C9D9 88BD E825  08D9 B1A7 0E4F 8DCD 0366 |
-| Tim Ruffing | 09E0 3F87 1092 E40E 106E  902B 33BC 86AB 80FF 5516 |
-
-You can import a key by running the following command with that individual’s fingerprint: `gpg --keyserver hkps://keys.openpgp.org --recv-keys "<fingerprint>"` Ensure that you put quotes around fingerprints containing spaces.

external/secp256k1/build-aux/m4/bitcoin_secp.m4

@@ -1,75 +0,0 @@
-dnl escape "$0x" below using the m4 quadrigaph @S|@, and escape it again with a \ for the shell.
-AC_DEFUN([SECP_X86_64_ASM_CHECK],[
-AC_MSG_CHECKING(for x86_64 assembly availability)
-AC_LINK_IFELSE([AC_LANG_PROGRAM([[
-  #include <stdint.h>]],[[
-  uint64_t a = 11, tmp;
-  __asm__ __volatile__("movq \@S|@0x100000000,%1; mulq %%rsi" : "+a"(a) : "S"(tmp) : "cc", "%rdx");
-  ]])], [has_x86_64_asm=yes], [has_x86_64_asm=no])
-AC_MSG_RESULT([$has_x86_64_asm])
-])
-
-AC_DEFUN([SECP_ARM32_ASM_CHECK], [
-  AC_MSG_CHECKING(for ARM32 assembly availability)
-  SECP_ARM32_ASM_CHECK_CFLAGS_saved_CFLAGS="$CFLAGS"
-  CFLAGS="-x assembler"
-  AC_LINK_IFELSE([AC_LANG_SOURCE([[
-    .syntax unified
-    .eabi_attribute 24, 1
-    .eabi_attribute 25, 1
-    .text
-    .global main
-    main:
-      ldr r0, =0x002A
-      mov r7, #1
-      swi 0   
-    ]])], [has_arm32_asm=yes], [has_arm32_asm=no])
-  AC_MSG_RESULT([$has_arm32_asm])
-  CFLAGS="$SECP_ARM32_ASM_CHECK_CFLAGS_saved_CFLAGS"
-])
-
-AC_DEFUN([SECP_VALGRIND_CHECK],[
-AC_MSG_CHECKING([for valgrind support])
-if test x"$has_valgrind" != x"yes"; then
-  CPPFLAGS_TEMP="$CPPFLAGS"
-  CPPFLAGS="$VALGRIND_CPPFLAGS $CPPFLAGS"
-  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-    #include <valgrind/memcheck.h>
-  ]], [[
-    #if defined(NVALGRIND)
-    #  error "Valgrind does not support this platform."
-    #endif
-  ]])], [has_valgrind=yes])
-  CPPFLAGS="$CPPFLAGS_TEMP"
-fi
-AC_MSG_RESULT($has_valgrind)
-])
-
-dnl SECP_TRY_APPEND_CFLAGS(flags, VAR)
-dnl Append flags to VAR if CC accepts them.
-AC_DEFUN([SECP_TRY_APPEND_CFLAGS], [
-  AC_MSG_CHECKING([if ${CC} supports $1])
-  SECP_TRY_APPEND_CFLAGS_saved_CFLAGS="$CFLAGS"
-  CFLAGS="$1 $CFLAGS"
-  AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])], [flag_works=yes], [flag_works=no])
-  AC_MSG_RESULT($flag_works)
-  CFLAGS="$SECP_TRY_APPEND_CFLAGS_saved_CFLAGS"
-  if test x"$flag_works" = x"yes"; then
-    $2="$$2 $1"
-  fi
-  unset flag_works
-  AC_SUBST($2)
-])
-
-dnl SECP_SET_DEFAULT(VAR, default, default-dev-mode)
-dnl Set VAR to default or default-dev-mode, depending on whether dev mode is enabled
-AC_DEFUN([SECP_SET_DEFAULT], [
-  if test "${enable_dev_mode+set}" != set; then
-    AC_MSG_ERROR([[Set enable_dev_mode before calling SECP_SET_DEFAULT]])
-  fi
-  if test x"$enable_dev_mode" = x"yes"; then
-    $1="$3"
-  else
-    $1="$2"
-  fi
-])

external/secp256k1/ci/cirrus.sh

@@ -1,118 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-export LC_ALL=C
-
-# Print relevant CI environment to allow reproducing the job outside of CI.
-print_environment() {
-    # Turn off -x because it messes up the output
-    set +x
-    # There are many ways to print variable names and their content. This one
-    # does not rely on bash.
-    for var in WERROR_CFLAGS MAKEFLAGS BUILD \
-            ECMULTWINDOW ECMULTGENPRECISION ASM WIDEMUL WITH_VALGRIND EXTRAFLAGS \
-            EXPERIMENTAL ECDH RECOVERY SCHNORRSIG \
-            SECP256K1_TEST_ITERS BENCH SECP256K1_BENCH_ITERS CTIMETESTS\
-            EXAMPLES \
-            HOST WRAPPER_CMD \
-            CC CFLAGS CPPFLAGS AR NM
-    do
-        eval "isset=\${$var+x}"
-        if [ -n "$isset" ]; then
-            eval "val=\${$var}"
-            # shellcheck disable=SC2154
-            printf '%s="%s" ' "$var" "$val"
-        fi
-    done
-    echo "$0"
-    set -x
-}
-print_environment
-
-# Start persistent wineserver if necessary.
-# This speeds up jobs with many invocations of wine (e.g., ./configure with MSVC) tremendously.
-case "$WRAPPER_CMD" in
-    *wine*)
-        # Make sure to shutdown wineserver whenever we exit.
-        trap "wineserver -k || true" EXIT INT HUP
-        # This is apparently only reliable when we run a dummy command such as "hh.exe" afterwards.
-        wineserver -p && wine hh.exe
-        ;;
-esac
-
-env >> test_env.log
-
-if [ -n "${CC+x}" ]; then
-    # The MSVC compiler "cl" doesn't understand "-v"
-    $CC -v || true
-fi
-if [ "$WITH_VALGRIND" = "yes" ]; then
-    valgrind --version
-fi
-if [ -n "$WRAPPER_CMD" ]; then
-    $WRAPPER_CMD --version
-fi
-
-./autogen.sh
-
-./configure \
-    --enable-experimental="$EXPERIMENTAL" \
-    --with-test-override-wide-multiply="$WIDEMUL" --with-asm="$ASM" \
-    --with-ecmult-window="$ECMULTWINDOW" \
-    --with-ecmult-gen-precision="$ECMULTGENPRECISION" \
-    --enable-module-ecdh="$ECDH" --enable-module-recovery="$RECOVERY" \
-    --enable-module-schnorrsig="$SCHNORRSIG" \
-    --enable-examples="$EXAMPLES" \
-    --enable-ctime-tests="$CTIMETESTS" \
-    --with-valgrind="$WITH_VALGRIND" \
-    --host="$HOST" $EXTRAFLAGS
-
-# We have set "-j<n>" in MAKEFLAGS.
-make
-
-# Print information about binaries so that we can see that the architecture is correct
-file *tests* || true
-file bench* || true
-file .libs/* || true
-
-# This tells `make check` to wrap test invocations.
-export LOG_COMPILER="$WRAPPER_CMD"
-
-make "$BUILD"
-
-# Using the local `libtool` because on macOS the system's libtool has nothing to do with GNU libtool
-EXEC='./libtool --mode=execute'
-if [ -n "$WRAPPER_CMD" ]
-then
-    EXEC="$EXEC $WRAPPER_CMD"
-fi
-
-if [ "$BENCH" = "yes" ]
-then
-    {
-        $EXEC ./bench_ecmult
-        $EXEC ./bench_internal
-        $EXEC ./bench
-    } >> bench.log 2>&1
-fi
-
-if [ "$CTIMETESTS" = "yes" ]
-then
-    if [ "$WITH_VALGRIND" = "yes" ]; then
-        ./libtool --mode=execute valgrind --error-exitcode=42 ./ctime_tests > ctime_tests.log 2>&1
-    else
-        $EXEC ./ctime_tests > ctime_tests.log 2>&1
-    fi
-fi
-
-# Rebuild precomputed files (if not cross-compiling).
-if [ -z "$HOST" ]
-then
-    make clean-precomp clean-testvectors
-    make precomp testvectors
-fi
-
-# Check that no repo files have been modified by the build.
-# (This fails for example if the precomp files need to be updated in the repo.)
-git diff --exit-code

external/secp256k1/ci/linux-debian.Dockerfile

@@ -1,37 +0,0 @@
-FROM debian:stable
-
-RUN dpkg --add-architecture i386 && \
-    dpkg --add-architecture s390x && \
-    dpkg --add-architecture armhf && \
-    dpkg --add-architecture arm64 && \
-    dpkg --add-architecture ppc64el
-
-# dkpg-dev: to make pkg-config work in cross-builds
-# llvm: for llvm-symbolizer, which is used by clang's UBSan for symbolized stack traces
-RUN apt-get update && apt-get install --no-install-recommends -y \
-        git ca-certificates \
-        make automake libtool pkg-config dpkg-dev valgrind qemu-user \
-        gcc clang llvm libc6-dbg \
-        g++ \
-        gcc-i686-linux-gnu libc6-dev-i386-cross libc6-dbg:i386 libubsan1:i386 libasan6:i386 \
-        gcc-s390x-linux-gnu libc6-dev-s390x-cross libc6-dbg:s390x \
-        gcc-arm-linux-gnueabihf libc6-dev-armhf-cross libc6-dbg:armhf \
-        gcc-aarch64-linux-gnu libc6-dev-arm64-cross libc6-dbg:arm64 \
-        gcc-powerpc64le-linux-gnu libc6-dev-ppc64el-cross libc6-dbg:ppc64el \
-        gcc-mingw-w64-x86-64-win32 wine64 wine \
-        gcc-mingw-w64-i686-win32 wine32 \
-        sagemath
-
-WORKDIR /root
-# The "wine" package provides a convience wrapper that we need
-RUN apt-get update && apt-get install --no-install-recommends -y \
-        git ca-certificates wine64 wine python3-simplejson python3-six msitools winbind procps && \
-    git clone https://github.com/mstorsjo/msvc-wine && \
-    mkdir /opt/msvc && \
-    python3 msvc-wine/vsdownload.py --accept-license --dest /opt/msvc Microsoft.VisualStudio.Workload.VCTools && \
-    msvc-wine/install.sh /opt/msvc
-
-# Initialize the wine environment. Wait until the wineserver process has
-# exited before closing the session, to avoid corrupting the wine prefix.
-RUN wine64 wineboot --init && \
-    while (ps -A | grep wineserver) > /dev/null; do sleep 1; done

external/secp256k1/cmake/CheckArm32Assembly.cmake

@@ -1,6 +0,0 @@
-function(check_arm32_assembly)
-  try_compile(HAVE_ARM32_ASM
-    ${CMAKE_BINARY_DIR}/check_arm32_assembly
-    SOURCES ${CMAKE_SOURCE_DIR}/cmake/source_arm32.s
-  )
-endfunction()

external/secp256k1/cmake/CheckStringOptionValue.cmake

@@ -1,10 +0,0 @@
-function(check_string_option_value option)
-  get_property(expected_values CACHE ${option} PROPERTY STRINGS)
-  if(expected_values)
-    if(${option} IN_LIST expected_values)
-      return()
-    endif()
-    message(FATAL_ERROR "${option} value is \"${${option}}\", but must be one of ${expected_values}.")
-  endif()
-  message(AUTHOR_WARNING "The STRINGS property must be set before invoking `check_string_option_value' function.")
-endfunction()

external/secp256k1/cmake/CheckX86_64Assembly.cmake

@@ -1,14 +0,0 @@
-include(CheckCSourceCompiles)
-
-function(check_x86_64_assembly)
-  check_c_source_compiles("
-    #include <stdint.h>
-
-    int main()
-    {
-      uint64_t a = 11, tmp;
-      __asm__ __volatile__(\"movq $0x100000000,%1; mulq %%rsi\" : \"+a\"(a) : \"S\"(tmp) : \"cc\", \"%rdx\");
-    }
-  " HAVE_X86_64_ASM)
-  set(HAVE_X86_64_ASM ${HAVE_X86_64_ASM} PARENT_SCOPE)
-endfunction()

external/secp256k1/cmake/FindValgrind.cmake

@@ -1,41 +0,0 @@
-if(CMAKE_HOST_APPLE)
-  find_program(BREW_COMMAND brew)
-  execute_process(
-    COMMAND ${BREW_COMMAND} --prefix valgrind
-    OUTPUT_VARIABLE valgrind_brew_prefix
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-endif()
-
-set(hints_paths)
-if(valgrind_brew_prefix)
-  set(hints_paths ${valgrind_brew_prefix}/include)
-endif()
-
-find_path(Valgrind_INCLUDE_DIR
-  NAMES valgrind/memcheck.h
-  HINTS ${hints_paths}
-)
-
-if(Valgrind_INCLUDE_DIR)
-  include(CheckCSourceCompiles)
-  set(CMAKE_REQUIRED_INCLUDES ${Valgrind_INCLUDE_DIR})
-  check_c_source_compiles("
-    #include <valgrind/memcheck.h>
-    #if defined(NVALGRIND)
-    #  error \"Valgrind does not support this platform.\"
-    #endif
-
-    int main() {}
-  " Valgrind_WORKS)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Valgrind
-  REQUIRED_VARS Valgrind_INCLUDE_DIR Valgrind_WORKS
-)
-
-mark_as_advanced(
-  Valgrind_INCLUDE_DIR
-)

external/secp256k1/cmake/TryAppendCFlags.cmake

@@ -1,24 +0,0 @@
-include(CheckCCompilerFlag)
-
-function(secp256k1_check_c_flags_internal flags output)
-  string(MAKE_C_IDENTIFIER "${flags}" result)
-  string(TOUPPER "${result}" result)
-  set(result "C_SUPPORTS_${result}")
-  if(NOT MSVC)
-    set(CMAKE_REQUIRED_FLAGS "-Werror")
-  endif()
-
-  # This avoids running a linker.
-  set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
-  check_c_compiler_flag("${flags}" ${result})
-
-  set(${output} ${${result}} PARENT_SCOPE)
-endfunction()
-
-# Append flags to the COMPILE_OPTIONS directory property if CC accepts them.
-macro(try_append_c_flags)
-  secp256k1_check_c_flags_internal("${ARGV}" result)
-  if(result)
-    add_compile_options(${ARGV})
-  endif()
-endmacro()

external/secp256k1/cmake/arm-linux-gnueabihf.toolchain.cmake

@@ -1,3 +0,0 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR arm)
-set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)

external/secp256k1/cmake/config.cmake.in

@@ -1,5 +0,0 @@
-@PACKAGE_INIT@
-
-include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")
-
-check_required_components(@PROJECT_NAME@)

external/secp256k1/cmake/source_arm32.s

@@ -1,9 +0,0 @@
-.syntax unified
-.eabi_attribute 24, 1
-.eabi_attribute 25, 1
-.text
-.global main
-main:
-	ldr	r0, =0x002A
-	mov	r7, #1
-	swi	0   

external/secp256k1/cmake/x86_64-w64-mingw32.toolchain.cmake

@@ -1,3 +0,0 @@
-set(CMAKE_SYSTEM_NAME Windows)
-set(CMAKE_SYSTEM_PROCESSOR x86_64)
-set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc)

external/secp256k1/configure.ac

@@ -1,477 +0,0 @@
-AC_PREREQ([2.60])
-
-# The package (a.k.a. release) version is based on semantic versioning 2.0.0 of
-# the API. All changes in experimental modules are treated as
-# backwards-compatible and therefore at most increase the minor version.
-define(_PKG_VERSION_MAJOR, 0)
-define(_PKG_VERSION_MINOR, 3)
-define(_PKG_VERSION_PATCH, 2)
-define(_PKG_VERSION_IS_RELEASE, true)
-
-# The library version is based on libtool versioning of the ABI. The set of
-# rules for updating the version can be found here:
-# https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
-# All changes in experimental modules are treated as if they don't affect the
-# interface and therefore only increase the revision.
-define(_LIB_VERSION_CURRENT, 2)
-define(_LIB_VERSION_REVISION, 2)
-define(_LIB_VERSION_AGE, 0)
-
-AC_INIT([libsecp256k1],m4_join([.], _PKG_VERSION_MAJOR, _PKG_VERSION_MINOR, _PKG_VERSION_PATCH)m4_if(_PKG_VERSION_IS_RELEASE, [true], [], [-dev]),[https://github.com/bitcoin-core/secp256k1/issues],[libsecp256k1],[https://github.com/bitcoin-core/secp256k1])
-
-AC_CONFIG_AUX_DIR([build-aux])
-AC_CONFIG_MACRO_DIR([build-aux/m4])
-AC_CANONICAL_HOST
-
-# Require Automake 1.11.2 for AM_PROG_AR
-AM_INIT_AUTOMAKE([1.11.2 foreign subdir-objects])
-
-# Make the compilation flags quiet unless V=1 is used.
-m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
-
-if test "${CFLAGS+set}" = "set"; then
-  CFLAGS_overridden=yes
-else
-  CFLAGS_overridden=no
-fi
-AC_PROG_CC
-AM_PROG_AS
-AM_PROG_AR
-
-# Clear some cache variables as a workaround for a bug that appears due to a bad
-# interaction between AM_PROG_AR and LT_INIT when combining MSVC's archiver lib.exe.
-# https://debbugs.gnu.org/cgi/bugreport.cgi?bug=54421
-AS_UNSET(ac_cv_prog_AR)
-AS_UNSET(ac_cv_prog_ac_ct_AR)
-LT_INIT([win32-dll])
-
-build_windows=no
-
-case $host_os in
-  *darwin*)
-     if  test x$cross_compiling != xyes; then
-       AC_CHECK_PROG([BREW], brew, brew)
-       if test x$BREW = xbrew; then
-         # These Homebrew packages may be keg-only, meaning that they won't be found
-         # in expected paths because they may conflict with system files. Ask
-         # Homebrew where each one is located, then adjust paths accordingly.
-         if $BREW list --versions valgrind >/dev/null; then
-           valgrind_prefix=$($BREW --prefix valgrind 2>/dev/null)
-           VALGRIND_CPPFLAGS="-I$valgrind_prefix/include"
-         fi
-       else
-         AC_CHECK_PROG([PORT], port, port)
-         # If homebrew isn't installed and macports is, add the macports default paths
-         # as a last resort.
-         if test x$PORT = xport; then
-           CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
-           LDFLAGS="$LDFLAGS -L/opt/local/lib"
-         fi
-       fi
-     fi
-   ;;
-   cygwin*|mingw*)
-     build_windows=yes
-   ;;
-esac
-
-# Try if some desirable compiler flags are supported and append them to SECP_CFLAGS.
-#
-# These are our own flags, so we append them to our own SECP_CFLAGS variable (instead of CFLAGS) as
-# recommended in the automake manual (Section "Flag Variables Ordering"). CFLAGS belongs to the user
-# and we are not supposed to touch it. In the Makefile, we will need to ensure that SECP_CFLAGS
-# is prepended to CFLAGS when invoking the compiler so that the user always has the last word (flag).
-#
-# Another advantage of not touching CFLAGS is that the contents of CFLAGS will be picked up by
-# libtool for compiling helper executables. For example, when compiling for Windows, libtool will
-# generate entire wrapper executables (instead of simple wrapper scripts as on Unix) to ensure
-# proper operation of uninstalled programs linked by libtool against the uninstalled shared library.
-# These executables are compiled from C source file for which our flags may not be appropriate,
-# e.g., -std=c89 flag has lead to undesirable warnings in the past.
-#
-# TODO We should analogously not touch CPPFLAGS and LDFLAGS but currently there are no issues.
-AC_DEFUN([SECP_TRY_APPEND_DEFAULT_CFLAGS], [
-    # GCC and compatible (incl. clang)
-    if test "x$GCC" = "xyes"; then
-      # Try to append -Werror to CFLAGS temporarily. Otherwise checks for some unsupported
-      # flags will succeed.
-      # Note that failure to append -Werror does not necessarily mean that -Werror is not
-      # supported. The compiler may already be warning about something unrelated, for example
-      # about some path issue. If that is the case, -Werror cannot be used because all
-      # of those warnings would be turned into errors.
-      SECP_TRY_APPEND_DEFAULT_CFLAGS_saved_CFLAGS="$CFLAGS"
-      SECP_TRY_APPEND_CFLAGS([-Werror], CFLAGS)
-
-      SECP_TRY_APPEND_CFLAGS([-std=c89 -pedantic -Wno-long-long -Wnested-externs -Wshadow -Wstrict-prototypes -Wundef], $1) # GCC >= 3.0, -Wlong-long is implied by -pedantic.
-      SECP_TRY_APPEND_CFLAGS([-Wno-overlength-strings], $1) # GCC >= 4.2, -Woverlength-strings is implied by -pedantic.
-      SECP_TRY_APPEND_CFLAGS([-Wall], $1) # GCC >= 2.95 and probably many other compilers
-      SECP_TRY_APPEND_CFLAGS([-Wno-unused-function], $1) # GCC >= 3.0, -Wunused-function is implied by -Wall.
-      SECP_TRY_APPEND_CFLAGS([-Wextra], $1) # GCC >= 3.4, this is the newer name of -W, which we don't use because older GCCs will warn about unused functions.
-      SECP_TRY_APPEND_CFLAGS([-Wcast-align], $1) # GCC >= 2.95
-      SECP_TRY_APPEND_CFLAGS([-Wcast-align=strict], $1) # GCC >= 8.0
-      SECP_TRY_APPEND_CFLAGS([-Wconditional-uninitialized], $1) # Clang >= 3.0 only
-      SECP_TRY_APPEND_CFLAGS([-Wreserved-identifier], $1) # Clang >= 13.0 only
-      SECP_TRY_APPEND_CFLAGS([-fvisibility=hidden], $1) # GCC >= 4.0
-
-      CFLAGS="$SECP_TRY_APPEND_DEFAULT_CFLAGS_saved_CFLAGS"
-    fi
-
-    # MSVC
-    # Assume MSVC if we're building for Windows but not with GCC or compatible;
-    # libtool makes the same assumption internally.
-    # Note that "/opt" and "-opt" are equivalent for MSVC; we use "-opt" because "/opt" looks like a path.
-    if test x"$GCC" != x"yes" && test x"$build_windows" = x"yes"; then
-      SECP_TRY_APPEND_CFLAGS([-W2 -wd4146], $1) # Moderate warning level, disable warning C4146 "unary minus operator applied to unsigned type, result still unsigned"
-      # We pass -ignore:4217 to the MSVC linker to suppress warning 4217 when
-      # importing variables from a statically linked secp256k1.
-      # (See the libtool manual, section "Windows DLLs" for background.)
-      # Unfortunately, libtool tries to be too clever and strips "-Xlinker arg"
-      # into "arg", so this will be " -Xlinker -ignore:4217" after stripping.
-      LDFLAGS="-Xlinker -Xlinker -Xlinker -ignore:4217 $LDFLAGS" 
-    fi
-])
-SECP_TRY_APPEND_DEFAULT_CFLAGS(SECP_CFLAGS)
-
-###
-### Define config arguments
-###
-
-# In dev mode, we enable all binaries and modules by default but individual options can still be overridden explicitly.
-# Check for dev mode first because SECP_SET_DEFAULT needs enable_dev_mode set.
-AC_ARG_ENABLE(dev_mode, [], [],
-    [enable_dev_mode=no])
-
-AC_ARG_ENABLE(benchmark,
-    AS_HELP_STRING([--enable-benchmark],[compile benchmark [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_benchmark], [yes], [yes])])
-
-AC_ARG_ENABLE(coverage,
-    AS_HELP_STRING([--enable-coverage],[enable compiler flags to support kcov coverage analysis [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_coverage], [no], [no])])
-
-AC_ARG_ENABLE(tests,
-    AS_HELP_STRING([--enable-tests],[compile tests [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_tests], [yes], [yes])])
-
-AC_ARG_ENABLE(ctime_tests,
-    AS_HELP_STRING([--enable-ctime-tests],[compile constant-time tests [default=yes if valgrind enabled]]), [],
-    [SECP_SET_DEFAULT([enable_ctime_tests], [auto], [auto])])
-
-AC_ARG_ENABLE(experimental,
-    AS_HELP_STRING([--enable-experimental],[allow experimental configure options [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_experimental], [no], [yes])])
-
-AC_ARG_ENABLE(exhaustive_tests,
-    AS_HELP_STRING([--enable-exhaustive-tests],[compile exhaustive tests [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_exhaustive_tests], [yes], [yes])])
-
-AC_ARG_ENABLE(examples,
-    AS_HELP_STRING([--enable-examples],[compile the examples [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_examples], [no], [yes])])
-
-AC_ARG_ENABLE(module_ecdh,
-    AS_HELP_STRING([--enable-module-ecdh],[enable ECDH module [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_module_ecdh], [yes], [yes])])
-
-AC_ARG_ENABLE(module_recovery,
-    AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_module_recovery], [no], [yes])])
-
-AC_ARG_ENABLE(module_extrakeys,
-    AS_HELP_STRING([--enable-module-extrakeys],[enable extrakeys module [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_module_extrakeys], [yes], [yes])])
-
-AC_ARG_ENABLE(module_schnorrsig,
-    AS_HELP_STRING([--enable-module-schnorrsig],[enable schnorrsig module [default=yes]]), [],
-    [SECP_SET_DEFAULT([enable_module_schnorrsig], [yes], [yes])])
-
-AC_ARG_ENABLE(external_default_callbacks,
-    AS_HELP_STRING([--enable-external-default-callbacks],[enable external default callback functions [default=no]]), [],
-    [SECP_SET_DEFAULT([enable_external_default_callbacks], [no], [no])])
-
-# Test-only override of the (autodetected by the C code) "widemul" setting.
-# Legal values are:
-#  * int64 (for [u]int64_t),
-#  * int128 (for [unsigned] __int128),
-#  * int128_struct (for int128 implemented as a structure),
-#  *  and auto (the default).
-AC_ARG_WITH([test-override-wide-multiply], [] ,[set_widemul=$withval], [set_widemul=auto])
-
-AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm32|no|auto],
-[assembly optimizations to use (experimental: arm32) [default=auto]])],[req_asm=$withval], [req_asm=auto])
-
-AC_ARG_WITH([ecmult-window], [AS_HELP_STRING([--with-ecmult-window=SIZE|auto],
-[window size for ecmult precomputation for verification, specified as integer in range [2..24].]
-[Larger values result in possibly better performance at the cost of an exponentially larger precomputed table.]
-[The table will store 2^(SIZE-1) * 64 bytes of data but can be larger in memory due to platform-specific padding and alignment.]
-[A window size larger than 15 will require you delete the prebuilt precomputed_ecmult.c file so that it can be rebuilt.]
-[For very large window sizes, use "make -j 1" to reduce memory use during compilation.]
-["auto" is a reasonable setting for desktop machines (currently 15). [default=auto]]
-)],
-[req_ecmult_window=$withval], [req_ecmult_window=auto])
-
-AC_ARG_WITH([ecmult-gen-precision], [AS_HELP_STRING([--with-ecmult-gen-precision=2|4|8|auto],
-[Precision bits to tune the precomputed table size for signing.]
-[The size of the table is 32kB for 2 bits, 64kB for 4 bits, 512kB for 8 bits of precision.]
-[A larger table size usually results in possible faster signing.]
-["auto" is a reasonable setting for desktop machines (currently 4). [default=auto]]
-)],
-[req_ecmult_gen_precision=$withval], [req_ecmult_gen_precision=auto])
-
-AC_ARG_WITH([valgrind], [AS_HELP_STRING([--with-valgrind=yes|no|auto],
-[Build with extra checks for running inside Valgrind [default=auto]]
-)],
-[req_valgrind=$withval], [req_valgrind=auto])
-
-###
-### Handle config options (except for modules)
-###
-
-if test x"$req_valgrind" = x"no"; then
-  enable_valgrind=no
-else
-  SECP_VALGRIND_CHECK
-  if test x"$has_valgrind" != x"yes"; then
-    if test x"$req_valgrind" = x"yes"; then
-      AC_MSG_ERROR([Valgrind support explicitly requested but valgrind/memcheck.h header not available])
-    fi
-    enable_valgrind=no
-  else
-    enable_valgrind=yes
-  fi
-fi
-
-if test x"$enable_ctime_tests" = x"auto"; then
-    enable_ctime_tests=$enable_valgrind
-fi
-
-if test x"$enable_coverage" = x"yes"; then
-    SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DCOVERAGE=1"
-    SECP_CFLAGS="-O0 --coverage $SECP_CFLAGS"
-    # If coverage is enabled, and the user has not overridden CFLAGS,
-    # override Autoconf's value "-g -O2" with "-g". Otherwise we'd end up
-    # with "-O0 --coverage -g -O2".
-    if test "$CFLAGS_overridden" = "no"; then
-      CFLAGS="-g"
-    fi
-    LDFLAGS="--coverage $LDFLAGS"
-else
-    # Most likely the CFLAGS already contain -O2 because that is autoconf's default.
-    # We still add it here because passing it twice is not an issue, and handling
-    # this case would just add unnecessary complexity (see #896).
-    SECP_CFLAGS="-O2 $SECP_CFLAGS"
-fi
-
-if test x"$req_asm" = x"auto"; then
-  SECP_X86_64_ASM_CHECK
-  if test x"$has_x86_64_asm" = x"yes"; then
-    set_asm=x86_64
-  fi
-  if test x"$set_asm" = x; then
-    set_asm=no
-  fi
-else
-  set_asm=$req_asm
-  case $set_asm in
-  x86_64)
-    SECP_X86_64_ASM_CHECK
-    if test x"$has_x86_64_asm" != x"yes"; then
-      AC_MSG_ERROR([x86_64 assembly optimization requested but not available])
-    fi
-    ;;
-  arm32)
-    SECP_ARM32_ASM_CHECK
-    if test x"$has_arm32_asm" != x"yes"; then
-      AC_MSG_ERROR([ARM32 assembly optimization requested but not available])
-    fi
-    ;;
-  no)
-    ;;
-  *)
-    AC_MSG_ERROR([invalid assembly optimization selection])
-    ;;
-  esac
-fi
-
-# Select assembly optimization
-enable_external_asm=no
-
-case $set_asm in
-x86_64)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_ASM_X86_64=1"
-  ;;
-arm32)
-  enable_external_asm=yes
-  ;;
-no)
-  ;;
-*)
-  AC_MSG_ERROR([invalid assembly optimizations])
-  ;;
-esac
-
-if test x"$enable_external_asm" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_EXTERNAL_ASM=1"
-fi
-
-
-# Select wide multiplication implementation
-case $set_widemul in
-int128_struct)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT128_STRUCT=1"
-  ;;
-int128)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT128=1"
-  ;;
-int64)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT64=1"
-  ;;
-auto)
-  ;;
-*)
-  AC_MSG_ERROR([invalid wide multiplication implementation])
-  ;;
-esac
-
-# Set ecmult window size
-if test x"$req_ecmult_window" = x"auto"; then
-  set_ecmult_window=15
-else
-  set_ecmult_window=$req_ecmult_window
-fi
-
-error_window_size=['window size for ecmult precomputation not an integer in range [2..24] or "auto"']
-case $set_ecmult_window in
-''|*[[!0-9]]*)
-  # no valid integer
-  AC_MSG_ERROR($error_window_size)
-  ;;
-*)
-  if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
-    # not in range
-    AC_MSG_ERROR($error_window_size)
-  fi
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DECMULT_WINDOW_SIZE=$set_ecmult_window"
-  ;;
-esac
-
-# Set ecmult gen precision
-if test x"$req_ecmult_gen_precision" = x"auto"; then
-  set_ecmult_gen_precision=4
-else
-  set_ecmult_gen_precision=$req_ecmult_gen_precision
-fi
-
-case $set_ecmult_gen_precision in
-2|4|8)
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DECMULT_GEN_PREC_BITS=$set_ecmult_gen_precision"
-  ;;
-*)
-  AC_MSG_ERROR(['ecmult gen precision not 2, 4, 8 or "auto"'])
-  ;;
-esac
-
-if test x"$enable_valgrind" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES $VALGRIND_CPPFLAGS -DVALGRIND"
-fi
-
-# Add -Werror and similar flags passed from the outside (for testing, e.g., in CI).
-# We don't want to set the user variable CFLAGS in CI because this would disable
-# autoconf's logic for setting default CFLAGS, which we would like to test in CI.
-SECP_CFLAGS="$SECP_CFLAGS $WERROR_CFLAGS"
-
-###
-### Handle module options
-###
-
-if test x"$enable_module_ecdh" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_ECDH=1"
-fi
-
-if test x"$enable_module_recovery" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_RECOVERY=1"
-fi
-
-if test x"$enable_module_schnorrsig" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_SCHNORRSIG=1"
-  enable_module_extrakeys=yes
-fi
-
-# Test if extrakeys is set after the schnorrsig module to allow the schnorrsig
-# module to set enable_module_extrakeys=yes
-if test x"$enable_module_extrakeys" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_EXTRAKEYS=1"
-fi
-
-if test x"$enable_external_default_callbacks" = x"yes"; then
-  SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_EXTERNAL_DEFAULT_CALLBACKS=1"
-fi
-
-###
-### Check for --enable-experimental if necessary
-###
-
-if test x"$enable_experimental" = x"yes"; then
-  AC_MSG_NOTICE([******])
-  AC_MSG_NOTICE([WARNING: experimental build])
-  AC_MSG_NOTICE([Experimental features do not have stable APIs or properties, and may not be safe for production use.])
-  AC_MSG_NOTICE([******])
-else
-  if test x"$set_asm" = x"arm32"; then
-    AC_MSG_ERROR([ARM32 assembly optimization is experimental. Use --enable-experimental to allow.])
-  fi
-fi
-
-###
-### Generate output
-###
-
-AC_CONFIG_FILES([Makefile libsecp256k1.pc])
-AC_SUBST(SECP_CFLAGS)
-AC_SUBST(SECP_CONFIG_DEFINES)
-AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
-AM_CONDITIONAL([USE_TESTS], [test x"$enable_tests" != x"no"])
-AM_CONDITIONAL([USE_CTIME_TESTS], [test x"$enable_ctime_tests" = x"yes"])
-AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$enable_exhaustive_tests" != x"no"])
-AM_CONDITIONAL([USE_EXAMPLES], [test x"$enable_examples" != x"no"])
-AM_CONDITIONAL([USE_BENCHMARK], [test x"$enable_benchmark" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_EXTRAKEYS], [test x"$enable_module_extrakeys" = x"yes"])
-AM_CONDITIONAL([ENABLE_MODULE_SCHNORRSIG], [test x"$enable_module_schnorrsig" = x"yes"])
-AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$enable_external_asm" = x"yes"])
-AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm32"])
-AM_CONDITIONAL([BUILD_WINDOWS], [test "$build_windows" = "yes"])
-AC_SUBST(LIB_VERSION_CURRENT, _LIB_VERSION_CURRENT)
-AC_SUBST(LIB_VERSION_REVISION, _LIB_VERSION_REVISION)
-AC_SUBST(LIB_VERSION_AGE, _LIB_VERSION_AGE)
-
-AC_OUTPUT
-
-echo
-echo "Build Options:"
-echo "  with external callbacks = $enable_external_default_callbacks"
-echo "  with benchmarks         = $enable_benchmark"
-echo "  with tests              = $enable_tests"
-echo "  with ctime tests        = $enable_ctime_tests"
-echo "  with coverage           = $enable_coverage"
-echo "  with examples           = $enable_examples"
-echo "  module ecdh             = $enable_module_ecdh"
-echo "  module recovery         = $enable_module_recovery"
-echo "  module extrakeys        = $enable_module_extrakeys"
-echo "  module schnorrsig       = $enable_module_schnorrsig"
-echo
-echo "  asm                     = $set_asm"
-echo "  ecmult window size      = $set_ecmult_window"
-echo "  ecmult gen prec. bits   = $set_ecmult_gen_precision"
-# Hide test-only options unless they're used.
-if test x"$set_widemul" != xauto; then
-echo "  wide multiplication     = $set_widemul"
-fi
-echo
-echo "  valgrind                = $enable_valgrind"
-echo "  CC                      = $CC"
-echo "  CPPFLAGS                = $CPPFLAGS"
-echo "  SECP_CFLAGS             = $SECP_CFLAGS"
-echo "  CFLAGS                  = $CFLAGS"
-echo "  LDFLAGS                 = $LDFLAGS"

external/secp256k1/doc/release-process.md

@@ -1,61 +0,0 @@
-# Release Process
-
-This document outlines the process for releasing versions of the form `$MAJOR.$MINOR.$PATCH`.
-
-We distinguish between two types of releases: *regular* and *maintenance* releases.
-Regular releases are releases of a new major or minor version as well as patches of the most recent release.
-Maintenance releases, on the other hand, are required for patches of older releases.
-
-You should coordinate with the other maintainers on the release date, if possible.
-This date will be part of the release entry in [CHANGELOG.md](../CHANGELOG.md) and it should match the dates of the remaining steps in the release process (including the date of the tag and the GitHub release).
-It is best if the maintainers are present during the release, so they can help ensure that the process is followed correctly and, in the case of a regular release, they are aware that they should not modify the master branch between merging the PR in step 1 and the PR in step 3.
-
-This process also assumes that there will be no minor releases for old major releases.
-
-## Regular release
-
-1. Open a PR to the master branch with a commit (using message `"release: prepare for $MAJOR.$MINOR.$PATCH"`, for example) that
-   * finalizes the release notes in [CHANGELOG.md](../CHANGELOG.md) (make sure to include an entry for `### ABI Compatibility`),
-   * sets `_PKG_VERSION_IS_RELEASE` to `true` in `configure.ac`, and
-   * if this is not a patch release
-       * updates `_PKG_VERSION_*` and `_LIB_VERSION_*`  in `configure.ac` and
-       * updates `project(libsecp256k1 VERSION ...)` and `${PROJECT_NAME}_LIB_VERSION_*` in `CMakeLists.txt`.
-2. After the PR is merged, tag the commit and push it:
-   ```
-   RELEASE_COMMIT=<merge commit of step 1>
-   git tag -s v$MAJOR.$MINOR.$PATCH -m "libsecp256k1 $MAJOR.$MINOR.$PATCH" $RELEASE_COMMIT
-   git push git@github.com:bitcoin-core/secp256k1.git v$MAJOR.$MINOR.$PATCH
-   ```
-3. Open a PR to the master branch with a commit (using message `"release cleanup: bump version after $MAJOR.$MINOR.$PATCH"`, for example) that
-   * sets `_PKG_VERSION_IS_RELEASE` to `false` and increments `_PKG_VERSION_PATCH` and `_LIB_VERSION_REVISION` in `configure.ac`, and
-   * increments the `$PATCH` component of `project(libsecp256k1 VERSION ...)` and `${PROJECT_NAME}_LIB_VERSION_REVISION` in `CMakeLists.txt`.
-
-   If other maintainers are not present to approve the PR, it can be merged without ACKs.
-4. Create a new GitHub release with a link to the corresponding entry in [CHANGELOG.md](../CHANGELOG.md).
-
-## Maintenance release
-
-Note that bugfixes only need to be backported to releases for which no compatible release without the bug exists.
-
-1. If `$PATCH = 1`, create maintenance branch `$MAJOR.$MINOR`:
-   ```
-   git checkout -b $MAJOR.$MINOR v$MAJOR.$MINOR.0
-   git push git@github.com:bitcoin-core/secp256k1.git $MAJOR.$MINOR
-   ```
-2. Open a pull request to the `$MAJOR.$MINOR` branch that
-   * includes the bugfixes,
-   * finalizes the release notes,
-   * increments `_PKG_VERSION_PATCH` and `_LIB_VERSION_REVISION` in `configure.ac`
-     and the `$PATCH` component of `project(libsecp256k1 VERSION ...)` and `${PROJECT_NAME}_LIB_VERSION_REVISION` in `CMakeLists.txt`
-     (with commit message `"release: bump versions for $MAJOR.$MINOR.$PATCH"`, for example).
-3. After the PRs are merged, update the release branch and tag the commit:
-   ```
-   git checkout $MAJOR.$MINOR && git pull
-   git tag -s v$MAJOR.$MINOR.$PATCH -m "libsecp256k1 $MAJOR.$MINOR.$PATCH"
-   ```
-4. Push tag:
-   ```
-   git push git@github.com:bitcoin-core/secp256k1.git v$MAJOR.$MINOR.$PATCH
-   ```
-5. Create a new GitHub release with a link to the corresponding entry in [CHANGELOG.md](../CHANGELOG.md).
-6. Open PR to the master branch that includes a commit (with commit message `"release notes: add $MAJOR.$MINOR.$PATCH"`, for example) that adds release notes to [CHANGELOG.md](../CHANGELOG.md).

external/secp256k1/doc/safegcd_implementation.md

@@ -1,819 +0,0 @@
-# The safegcd implementation in libsecp256k1 explained
-
-This document explains the modular inverse and Jacobi symbol implementations in the `src/modinv*.h` files.
-It is based on the paper
-["Fast constant-time gcd computation and modular inversion"](https://gcd.cr.yp.to/papers.html#safegcd)
-by Daniel J. Bernstein and Bo-Yin Yang. The references below are for the Date: 2019.04.13 version.
-
-The actual implementation is in C of course, but for demonstration purposes Python3 is used here.
-Most implementation aspects and optimizations are explained, except those that depend on the specific
-number representation used in the C code.
-
-## 1. Computing the Greatest Common Divisor (GCD) using divsteps
-
-The algorithm from the paper (section 11), at a very high level, is this:
-
-```python
-def gcd(f, g):
-    """Compute the GCD of an odd integer f and another integer g."""
-    assert f & 1  # require f to be odd
-    delta = 1     # additional state variable
-    while g != 0:
-        assert f & 1  # f will be odd in every iteration
-        if delta > 0 and g & 1:
-            delta, f, g = 1 - delta, g, (g - f) // 2
-        elif g & 1:
-            delta, f, g = 1 + delta, f, (g + f) // 2
-        else:
-            delta, f, g = 1 + delta, f, (g    ) // 2
-    return abs(f)
-```
-
-It computes the greatest common divisor of an odd integer *f* and any integer *g*. Its inner loop
-keeps rewriting the variables *f* and *g* alongside a state variable *δ* that starts at *1*, until
-*g=0* is reached. At that point, *|f|* gives the GCD. Each of the transitions in the loop is called a
-"division step" (referred to as divstep in what follows).
-
-For example, *gcd(21, 14)* would be computed as:
-- Start with *δ=1 f=21 g=14*
-- Take the third branch: *δ=2 f=21 g=7*
-- Take the first branch: *δ=-1 f=7 g=-7*
-- Take the second branch: *δ=0 f=7 g=0*
-- The answer *|f| = 7*.
-
-Why it works:
-- Divsteps can be decomposed into two steps (see paragraph 8.2 in the paper):
-  - (a) If *g* is odd, replace *(f,g)* with *(g,g-f)* or (f,g+f), resulting in an even *g*.
-  - (b) Replace *(f,g)* with *(f,g/2)* (where *g* is guaranteed to be even).
-- Neither of those two operations change the GCD:
-  - For (a), assume *gcd(f,g)=c*, then it must be the case that *f=a c* and *g=b c* for some integers *a*
-    and *b*. As *(g,g-f)=(b c,(b-a)c)* and *(f,f+g)=(a c,(a+b)c)*, the result clearly still has
-    common factor *c*. Reasoning in the other direction shows that no common factor can be added by
-    doing so either.
-  - For (b), we know that *f* is odd, so *gcd(f,g)* clearly has no factor *2*, and we can remove
-    it from *g*.
-- The algorithm will eventually converge to *g=0*. This is proven in the paper (see theorem G.3).
-- It follows that eventually we find a final value *f'* for which *gcd(f,g) = gcd(f',0)*. As the
-  gcd of *f'* and *0* is *|f'|* by definition, that is our answer.
-
-Compared to more [traditional GCD algorithms](https://en.wikipedia.org/wiki/Euclidean_algorithm), this one has the property of only ever looking at
-the low-order bits of the variables to decide the next steps, and being easy to make
-constant-time (in more low-level languages than Python). The *δ* parameter is necessary to
-guide the algorithm towards shrinking the numbers' magnitudes without explicitly needing to look
-at high order bits.
-
-Properties that will become important later:
-- Performing more divsteps than needed is not a problem, as *f* does not change anymore after *g=0*.
-- Only even numbers are divided by *2*. This means that when reasoning about it algebraically we
-  do not need to worry about rounding.
-- At every point during the algorithm's execution the next *N* steps only depend on the bottom *N*
-  bits of *f* and *g*, and on *δ*.
-
-
-## 2. From GCDs to modular inverses
-
-We want an algorithm to compute the inverse *a* of *x* modulo *M*, i.e. the number a such that *a x=1
-mod M*. This inverse only exists if the GCD of *x* and *M* is *1*, but that is always the case if *M* is
-prime and *0 < x < M*. In what follows, assume that the modular inverse exists.
-It turns out this inverse can be computed as a side effect of computing the GCD by keeping track
-of how the internal variables can be written as linear combinations of the inputs at every step
-(see the [extended Euclidean algorithm](https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm)).
-Since the GCD is *1*, such an algorithm will compute numbers *a* and *b* such that a&thinsp;x + b&thinsp;M = 1*.
-Taking that expression *mod M* gives *a&thinsp;x mod M = 1*, and we see that *a* is the modular inverse of *x
-mod M*.
-
-A similar approach can be used to calculate modular inverses using the divsteps-based GCD
-algorithm shown above, if the modulus *M* is odd. To do so, compute *gcd(f=M,g=x)*, while keeping
-track of extra variables *d* and *e*, for which at every step *d = f/x (mod M)* and *e = g/x (mod M)*.
-*f/x* here means the number which multiplied with *x* gives *f mod M*. As *f* and *g* are initialized to *M*
-and *x* respectively, *d* and *e* just start off being *0* (*M/x mod M = 0/x mod M = 0*) and *1* (*x/x mod M
-= 1*).
-
-```python
-def div2(M, x):
-    """Helper routine to compute x/2 mod M (where M is odd)."""
-    assert M & 1
-    if x & 1: # If x is odd, make it even by adding M.
-        x += M
-    # x must be even now, so a clean division by 2 is possible.
-    return x // 2
-
-def modinv(M, x):
-    """Compute the inverse of x mod M (given that it exists, and M is odd)."""
-    assert M & 1
-    delta, f, g, d, e = 1, M, x, 0, 1
-    while g != 0:
-        # Note that while division by two for f and g is only ever done on even inputs, this is
-        # not true for d and e, so we need the div2 helper function.
-        if delta > 0 and g & 1:
-            delta, f, g, d, e = 1 - delta, g, (g - f) // 2, e, div2(M, e - d)
-        elif g & 1:
-            delta, f, g, d, e = 1 + delta, f, (g + f) // 2, d, div2(M, e + d)
-        else:
-            delta, f, g, d, e = 1 + delta, f, (g    ) // 2, d, div2(M, e    )
-        # Verify that the invariants d=f/x mod M, e=g/x mod M are maintained.
-        assert f % M == (d * x) % M
-        assert g % M == (e * x) % M
-    assert f == 1 or f == -1  # |f| is the GCD, it must be 1
-    # Because of invariant d = f/x (mod M), 1/x = d/f (mod M). As |f|=1, d/f = d*f.
-    return (d * f) % M
-```
-
-Also note that this approach to track *d* and *e* throughout the computation to determine the inverse
-is different from the paper. There (see paragraph 12.1 in the paper) a transition matrix for the
-entire computation is determined (see section 3 below) and the inverse is computed from that.
-The approach here avoids the need for 2x2 matrix multiplications of various sizes, and appears to
-be faster at the level of optimization we're able to do in C.
-
-
-## 3. Batching multiple divsteps
-
-Every divstep can be expressed as a matrix multiplication, applying a transition matrix *(1/2 t)*
-to both vectors *[f, g]* and *[d, e]* (see paragraph 8.1 in the paper):
-
-```
-  t = [ u,  v ]
-      [ q,  r ]
-
-  [ out_f ] = (1/2 * t) * [ in_f ]
-  [ out_g ] =             [ in_g ]
-
-  [ out_d ] = (1/2 * t) * [ in_d ]  (mod M)
-  [ out_e ]               [ in_e ]
-```
-
-where *(u, v, q, r)* is *(0, 2, -1, 1)*, *(2, 0, 1, 1)*, or *(2, 0, 0, 1)*, depending on which branch is
-taken. As above, the resulting *f* and *g* are always integers.
-
-Performing multiple divsteps corresponds to a multiplication with the product of all the
-individual divsteps' transition matrices. As each transition matrix consists of integers
-divided by *2*, the product of these matrices will consist of integers divided by *2<sup>N</sup>* (see also
-theorem 9.2 in the paper). These divisions are expensive when updating *d* and *e*, so we delay
-them: we compute the integer coefficients of the combined transition matrix scaled by *2<sup>N</sup>*, and
-do one division by *2<sup>N</sup>* as a final step:
-
-```python
-def divsteps_n_matrix(delta, f, g):
-    """Compute delta and transition matrix t after N divsteps (multiplied by 2^N)."""
-    u, v, q, r = 1, 0, 0, 1 # start with identity matrix
-    for _ in range(N):
-        if delta > 0 and g & 1:
-            delta, f, g, u, v, q, r = 1 - delta, g, (g - f) // 2, 2*q, 2*r, q-u, r-v
-        elif g & 1:
-            delta, f, g, u, v, q, r = 1 + delta, f, (g + f) // 2, 2*u, 2*v, q+u, r+v
-        else:
-            delta, f, g, u, v, q, r = 1 + delta, f, (g    ) // 2, 2*u, 2*v, q  , r
-    return delta, (u, v, q, r)
-```
-
-As the branches in the divsteps are completely determined by the bottom *N* bits of *f* and *g*, this
-function to compute the transition matrix only needs to see those bottom bits. Furthermore all
-intermediate results and outputs fit in *(N+1)*-bit numbers (unsigned for *f* and *g*; signed for *u*, *v*,
-*q*, and *r*) (see also paragraph 8.3 in the paper). This means that an implementation using 64-bit
-integers could set *N=62* and compute the full transition matrix for 62 steps at once without any
-big integer arithmetic at all. This is the reason why this algorithm is efficient: it only needs
-to update the full-size *f*, *g*, *d*, and *e* numbers once every *N* steps.
-
-We still need functions to compute:
-
-```
-  [ out_f ] = (1/2^N * [ u,  v ]) * [ in_f ]
-  [ out_g ]   (        [ q,  r ])   [ in_g ]
-
-  [ out_d ] = (1/2^N * [ u,  v ]) * [ in_d ]  (mod M)
-  [ out_e ]   (        [ q,  r ])   [ in_e ]
-```
-
-Because the divsteps transformation only ever divides even numbers by two, the result of *t&thinsp;[f,g]* is always even. When *t* is a composition of *N* divsteps, it follows that the resulting *f*
-and *g* will be multiple of *2<sup>N</sup>*, and division by *2<sup>N</sup>* is simply shifting them down:
-
-```python
-def update_fg(f, g, t):
-    """Multiply matrix t/2^N with [f, g]."""
-    u, v, q, r = t
-    cf, cg = u*f + v*g, q*f + r*g
-    # (t / 2^N) should cleanly apply to [f,g] so the result of t*[f,g] should have N zero
-    # bottom bits.
-    assert cf % 2**N == 0
-    assert cg % 2**N == 0
-    return cf >> N, cg >> N
-```
-
-The same is not true for *d* and *e*, and we need an equivalent of the `div2` function for division by *2<sup>N</sup> mod M*.
-This is easy if we have precomputed *1/M mod 2<sup>N</sup>* (which always exists for odd *M*):
-
-```python
-def div2n(M, Mi, x):
-    """Compute x/2^N mod M, given Mi = 1/M mod 2^N."""
-    assert (M * Mi) % 2**N == 1
-    # Find a factor m such that m*M has the same bottom N bits as x. We want:
-    #     (m * M) mod 2^N = x mod 2^N
-    # <=> m mod 2^N = (x / M) mod 2^N
-    # <=> m mod 2^N = (x * Mi) mod 2^N
-    m = (Mi * x) % 2**N
-    # Subtract that multiple from x, cancelling its bottom N bits.
-    x -= m * M
-    # Now a clean division by 2^N is possible.
-    assert x % 2**N == 0
-    return (x >> N) % M
-
-def update_de(d, e, t, M, Mi):
-    """Multiply matrix t/2^N with [d, e], modulo M."""
-    u, v, q, r = t
-    cd, ce = u*d + v*e, q*d + r*e
-    return div2n(M, Mi, cd), div2n(M, Mi, ce)
-```
-
-With all of those, we can write a version of `modinv` that performs *N* divsteps at once:
-
-```python3
-def modinv(M, Mi, x):
-    """Compute the modular inverse of x mod M, given Mi=1/M mod 2^N."""
-    assert M & 1
-    delta, f, g, d, e = 1, M, x, 0, 1
-    while g != 0:
-        # Compute the delta and transition matrix t for the next N divsteps (this only needs
-        # (N+1)-bit signed integer arithmetic).
-        delta, t = divsteps_n_matrix(delta, f % 2**N, g % 2**N)
-        # Apply the transition matrix t to [f, g]:
-        f, g = update_fg(f, g, t)
-        # Apply the transition matrix t to [d, e]:
-        d, e = update_de(d, e, t, M, Mi)
-    return (d * f) % M
-```
-
-This means that in practice we'll always perform a multiple of *N* divsteps. This is not a problem
-because once *g=0*, further divsteps do not affect *f*, *g*, *d*, or *e* anymore (only *&delta;* keeps
-increasing). For variable time code such excess iterations will be mostly optimized away in later
-sections.
-
-
-## 4. Avoiding modulus operations
-
-So far, there are two places where we compute a remainder of big numbers modulo *M*: at the end of
-`div2n` in every `update_de`, and at the very end of `modinv` after potentially negating *d* due to the
-sign of *f*. These are relatively expensive operations when done generically.
-
-To deal with the modulus operation in `div2n`, we simply stop requiring *d* and *e* to be in range
-*[0,M)* all the time. Let's start by inlining `div2n` into `update_de`, and dropping the modulus
-operation at the end:
-
-```python
-def update_de(d, e, t, M, Mi):
-    """Multiply matrix t/2^N with [d, e] mod M, given Mi=1/M mod 2^N."""
-    u, v, q, r = t
-    cd, ce = u*d + v*e, q*d + r*e
-    # Cancel out bottom N bits of cd and ce.
-    md = -((Mi * cd) % 2**N)
-    me = -((Mi * ce) % 2**N)
-    cd += md * M
-    ce += me * M
-    # And cleanly divide by 2**N.
-    return cd >> N, ce >> N
-```
-
-Let's look at bounds on the ranges of these numbers. It can be shown that *|u|+|v|* and *|q|+|r|*
-never exceed *2<sup>N</sup>* (see paragraph 8.3 in the paper), and thus a multiplication with *t* will have
-outputs whose absolute values are at most *2<sup>N</sup>* times the maximum absolute input value. In case the
-inputs *d* and *e* are in *(-M,M)*, which is certainly true for the initial values *d=0* and *e=1* assuming
-*M > 1*, the multiplication results in numbers in range *(-2<sup>N</sup>M,2<sup>N</sup>M)*. Subtracting less than *2<sup>N</sup>*
-times *M* to cancel out *N* bits brings that up to *(-2<sup>N+1</sup>M,2<sup>N</sup>M)*, and
-dividing by *2<sup>N</sup>* at the end takes it to *(-2M,M)*. Another application of `update_de` would take that
-to *(-3M,2M)*, and so forth. This progressive expansion of the variables' ranges can be
-counteracted by incrementing *d* and *e* by *M* whenever they're negative:
-
-```python
-    ...
-    if d < 0:
-        d += M
-    if e < 0:
-        e += M
-    cd, ce = u*d + v*e, q*d + r*e
-    # Cancel out bottom N bits of cd and ce.
-    ...
-```
-
-With inputs in *(-2M,M)*, they will first be shifted into range *(-M,M)*, which means that the
-output will again be in *(-2M,M)*, and this remains the case regardless of how many `update_de`
-invocations there are. In what follows, we will try to make this more efficient.
-
-Note that increasing *d* by *M* is equal to incrementing *cd* by *u&thinsp;M* and *ce* by *q&thinsp;M*. Similarly,
-increasing *e* by *M* is equal to incrementing *cd* by *v&thinsp;M* and *ce* by *r&thinsp;M*. So we could instead write:
-
-```python
-    ...
-    cd, ce = u*d + v*e, q*d + r*e
-    # Perform the equivalent of incrementing d, e by M when they're negative.
-    if d < 0:
-        cd += u*M
-        ce += q*M
-    if e < 0:
-        cd += v*M
-        ce += r*M
-    # Cancel out bottom N bits of cd and ce.
-    md = -((Mi * cd) % 2**N)
-    me = -((Mi * ce) % 2**N)
-    cd += md * M
-    ce += me * M
-    ...
-```
-
-Now note that we have two steps of corrections to *cd* and *ce* that add multiples of *M*: this
-increment, and the decrement that cancels out bottom bits. The second one depends on the first
-one, but they can still be efficiently combined by only computing the bottom bits of *cd* and *ce*
-at first, and using that to compute the final *md*, *me* values:
-
-```python
-def update_de(d, e, t, M, Mi):
-    """Multiply matrix t/2^N with [d, e], modulo M."""
-    u, v, q, r = t
-    md, me = 0, 0
-    # Compute what multiples of M to add to cd and ce.
-    if d < 0:
-        md += u
-        me += q
-    if e < 0:
-        md += v
-        me += r
-    # Compute bottom N bits of t*[d,e] + M*[md,me].
-    cd, ce = (u*d + v*e + md*M) % 2**N, (q*d + r*e + me*M) % 2**N
-    # Correct md and me such that the bottom N bits of t*[d,e] + M*[md,me] are zero.
-    md -= (Mi * cd) % 2**N
-    me -= (Mi * ce) % 2**N
-    # Do the full computation.
-    cd, ce = u*d + v*e + md*M, q*d + r*e + me*M
-    # And cleanly divide by 2**N.
-    return cd >> N, ce >> N
-```
-
-One last optimization: we can avoid the *md&thinsp;M* and *me&thinsp;M* multiplications in the bottom bits of *cd*
-and *ce* by moving them to the *md* and *me* correction:
-
-```python
-    ...
-    # Compute bottom N bits of t*[d,e].
-    cd, ce = (u*d + v*e) % 2**N, (q*d + r*e) % 2**N
-    # Correct md and me such that the bottom N bits of t*[d,e]+M*[md,me] are zero.
-    # Note that this is not the same as {md = (-Mi * cd) % 2**N} etc. That would also result in N
-    # zero bottom bits, but isn't guaranteed to be a reduction of [0,2^N) compared to the
-    # previous md and me values, and thus would violate our bounds analysis.
-    md -= (Mi*cd + md) % 2**N
-    me -= (Mi*ce + me) % 2**N
-    ...
-```
-
-The resulting function takes *d* and *e* in range *(-2M,M)* as inputs, and outputs values in the same
-range. That also means that the *d* value at the end of `modinv` will be in that range, while we want
-a result in *[0,M)*. To do that, we need a normalization function. It's easy to integrate the
-conditional negation of *d* (based on the sign of *f*) into it as well:
-
-```python
-def normalize(sign, v, M):
-    """Compute sign*v mod M, where v is in range (-2*M,M); output in [0,M)."""
-    assert sign == 1 or sign == -1
-    # v in (-2*M,M)
-    if v < 0:
-        v += M
-    # v in (-M,M). Now multiply v with sign (which can only be 1 or -1).
-    if sign == -1:
-        v = -v
-    # v in (-M,M)
-    if v < 0:
-        v += M
-    # v in [0,M)
-    return v
-```
-
-And calling it in `modinv` is simply:
-
-```python
-   ...
-   return normalize(f, d, M)
-```
-
-
-## 5. Constant-time operation
-
-The primary selling point of the algorithm is fast constant-time operation. What code flow still
-depends on the input data so far?
-
-- the number of iterations of the while *g &ne; 0* loop in `modinv`
-- the branches inside `divsteps_n_matrix`
-- the sign checks in `update_de`
-- the sign checks in `normalize`
-
-To make the while loop in `modinv` constant time it can be replaced with a constant number of
-iterations. The paper proves (Theorem 11.2) that *741* divsteps are sufficient for any *256*-bit
-inputs, and [safegcd-bounds](https://github.com/sipa/safegcd-bounds) shows that the slightly better bound *724* is
-sufficient even. Given that every loop iteration performs *N* divsteps, it will run a total of
-*&lceil;724/N&rceil;* times.
-
-To deal with the branches in `divsteps_n_matrix` we will replace them with constant-time bitwise
-operations (and hope the C compiler isn't smart enough to turn them back into branches; see
-`ctime_tests.c` for automated tests that this isn't the case). To do so, observe that a
-divstep can be written instead as (compare to the inner loop of `gcd` in section 1).
-
-```python
-    x = -f if delta > 0 else f         # set x equal to (input) -f or f
-    if g & 1:
-        g += x                         # set g to (input) g-f or g+f
-        if delta > 0:
-            delta = -delta
-            f += g                     # set f to (input) g (note that g was set to g-f before)
-    delta += 1
-    g >>= 1
-```
-
-To convert the above to bitwise operations, we rely on a trick to negate conditionally: per the
-definition of negative numbers in two's complement, (*-v == ~v + 1*) holds for every number *v*. As
-*-1* in two's complement is all *1* bits, bitflipping can be expressed as xor with *-1*. It follows
-that *-v == (v ^ -1) - (-1)*. Thus, if we have a variable *c* that takes on values *0* or *-1*, then
-*(v ^ c) - c* is *v* if *c=0* and *-v* if *c=-1*.
-
-Using this we can write:
-
-```python
-    x = -f if delta > 0 else f
-```
-
-in constant-time form as:
-
-```python
-    c1 = (-delta) >> 63
-    # Conditionally negate f based on c1:
-    x = (f ^ c1) - c1
-```
-
-To use that trick, we need a helper mask variable *c1* that resolves the condition *&delta;>0* to *-1*
-(if true) or *0* (if false). We compute *c1* using right shifting, which is equivalent to dividing by
-the specified power of *2* and rounding down (in Python, and also in C under the assumption of a typical two's complement system; see
-`assumptions.h` for tests that this is the case). Right shifting by *63* thus maps all
-numbers in range *[-2<sup>63</sup>,0)* to *-1*, and numbers in range *[0,2<sup>63</sup>)* to *0*.
-
-Using the facts that *x&0=0* and *x&(-1)=x* (on two's complement systems again), we can write:
-
-```python
-    if g & 1:
-        g += x
-```
-
-as:
-
-```python
-    # Compute c2=0 if g is even and c2=-1 if g is odd.
-    c2 = -(g & 1)
-    # This masks out x if g is even, and leaves x be if g is odd.
-    g += x & c2
-```
-
-Using the conditional negation trick again we can write:
-
-```python
-    if g & 1:
-        if delta > 0:
-            delta = -delta
-```
-
-as:
-
-```python
-    # Compute c3=-1 if g is odd and delta>0, and 0 otherwise.
-    c3 = c1 & c2
-    # Conditionally negate delta based on c3:
-    delta = (delta ^ c3) - c3
-```
-
-Finally:
-
-```python
-    if g & 1:
-        if delta > 0:
-            f += g
-```
-
-becomes:
-
-```python
-    f += g & c3
-```
-
-It turns out that this can be implemented more efficiently by applying the substitution
-*&eta;=-&delta;*. In this representation, negating *&delta;* corresponds to negating *&eta;*, and incrementing
-*&delta;* corresponds to decrementing *&eta;*. This allows us to remove the negation in the *c1*
-computation:
-
-```python
-    # Compute a mask c1 for eta < 0, and compute the conditional negation x of f:
-    c1 = eta >> 63
-    x = (f ^ c1) - c1
-    # Compute a mask c2 for odd g, and conditionally add x to g:
-    c2 = -(g & 1)
-    g += x & c2
-    # Compute a mask c for (eta < 0) and odd (input) g, and use it to conditionally negate eta,
-    # and add g to f:
-    c3 = c1 & c2
-    eta = (eta ^ c3) - c3
-    f += g & c3
-    # Incrementing delta corresponds to decrementing eta.
-    eta -= 1
-    g >>= 1
-```
-
-A variant of divsteps with better worst-case performance can be used instead: starting *&delta;* at
-*1/2* instead of *1*. This reduces the worst case number of iterations to *590* for *256*-bit inputs
-(which can be shown using convex hull analysis). In this case, the substitution *&zeta;=-(&delta;+1/2)*
-is used instead to keep the variable integral. Incrementing *&delta;* by *1* still translates to
-decrementing *&zeta;* by *1*, but negating *&delta;* now corresponds to going from *&zeta;* to *-(&zeta;+1)*, or
-*~&zeta;*. Doing that conditionally based on *c3* is simply:
-
-```python
-    ...
-    c3 = c1 & c2
-    zeta ^= c3
-    ...
-```
-
-By replacing the loop in `divsteps_n_matrix` with a variant of the divstep code above (extended to
-also apply all *f* operations to *u*, *v* and all *g* operations to *q*, *r*), a constant-time version of
-`divsteps_n_matrix` is obtained. The full code will be in section 7.
-
-These bit fiddling tricks can also be used to make the conditional negations and additions in
-`update_de` and `normalize` constant-time.
-
-
-## 6. Variable-time optimizations
-
-In section 5, we modified the `divsteps_n_matrix` function (and a few others) to be constant time.
-Constant time operations are only necessary when computing modular inverses of secret data. In
-other cases, it slows down calculations unnecessarily. In this section, we will construct a
-faster non-constant time `divsteps_n_matrix` function.
-
-To do so, first consider yet another way of writing the inner loop of divstep operations in
-`gcd` from section 1. This decomposition is also explained in the paper in section 8.2. We use
-the original version with initial *&delta;=1* and *&eta;=-&delta;* here.
-
-```python
-for _ in range(N):
-    if g & 1 and eta < 0:
-        eta, f, g = -eta, g, -f
-    if g & 1:
-        g += f
-    eta -= 1
-    g >>= 1
-```
-
-Whenever *g* is even, the loop only shifts *g* down and decreases *&eta;*. When *g* ends in multiple zero
-bits, these iterations can be consolidated into one step. This requires counting the bottom zero
-bits efficiently, which is possible on most platforms; it is abstracted here as the function
-`count_trailing_zeros`.
-
-```python
-def count_trailing_zeros(v):
-    """
-    When v is zero, consider all N zero bits as "trailing".
-    For a non-zero value v, find z such that v=(d<<z) for some odd d.
-    """
-    if v == 0:
-        return N
-    else:
-        return (v & -v).bit_length() - 1
-
-i = N # divsteps left to do
-while True:
-    # Get rid of all bottom zeros at once. In the first iteration, g may be odd and the following
-    # lines have no effect (until "if eta < 0").
-    zeros = min(i, count_trailing_zeros(g))
-    eta -= zeros
-    g >>= zeros
-    i -= zeros
-    if i == 0:
-        break
-    # We know g is odd now
-    if eta < 0:
-        eta, f, g = -eta, g, -f
-    g += f
-    # g is even now, and the eta decrement and g shift will happen in the next loop.
-```
-
-We can now remove multiple bottom *0* bits from *g* at once, but still need a full iteration whenever
-there is a bottom *1* bit. In what follows, we will get rid of multiple *1* bits simultaneously as
-well.
-
-Observe that as long as *&eta; &geq; 0*, the loop does not modify *f*. Instead, it cancels out bottom
-bits of *g* and shifts them out, and decreases *&eta;* and *i* accordingly - interrupting only when *&eta;*
-becomes negative, or when *i* reaches *0*. Combined, this is equivalent to adding a multiple of *f* to
-*g* to cancel out multiple bottom bits, and then shifting them out.
-
-It is easy to find what that multiple is: we want a number *w* such that *g+w&thinsp;f* has a few bottom
-zero bits. If that number of bits is *L*, we want *g+w&thinsp;f mod 2<sup>L</sup> = 0*, or *w = -g/f mod 2<sup>L</sup>*. Since *f*
-is odd, such a *w* exists for any *L*. *L* cannot be more than *i* steps (as we'd finish the loop before
-doing more) or more than *&eta;+1* steps (as we'd run `eta, f, g = -eta, g, -f` at that point), but
-apart from that, we're only limited by the complexity of computing *w*.
-
-This code demonstrates how to cancel up to 4 bits per step:
-
-```python
-NEGINV16 = [15, 5, 3, 9, 7, 13, 11, 1] # NEGINV16[n//2] = (-n)^-1 mod 16, for odd n
-i = N
-while True:
-    zeros = min(i, count_trailing_zeros(g))
-    eta -= zeros
-    g >>= zeros
-    i -= zeros
-    if i == 0:
-        break
-    # We know g is odd now
-    if eta < 0:
-        eta, f, g = -eta, g, -f
-    # Compute limit on number of bits to cancel
-    limit = min(min(eta + 1, i), 4)
-    # Compute w = -g/f mod 2**limit, using the table value for -1/f mod 2**4. Note that f is
-    # always odd, so its inverse modulo a power of two always exists.
-    w = (g * NEGINV16[(f & 15) // 2]) % (2**limit)
-    # As w = -g/f mod (2**limit), g+w*f mod 2**limit = 0 mod 2**limit.
-    g += w * f
-    assert g % (2**limit) == 0
-    # The next iteration will now shift out at least limit bottom zero bits from g.
-```
-
-By using a bigger table more bits can be cancelled at once. The table can also be implemented
-as a formula. Several formulas are known for computing modular inverses modulo powers of two;
-some can be found in Hacker's Delight second edition by Henry S. Warren, Jr. pages 245-247.
-Here we need the negated modular inverse, which is a simple transformation of those:
-
-- Instead of a 3-bit table:
-  - *-f* or *f ^ 6*
-- Instead of a 4-bit table:
-  - *1 - f(f + 1)*
-  - *-(f + (((f + 1) & 4) << 1))*
-- For larger tables the following technique can be used: if *w=-1/f mod 2<sup>L</sup>*, then *w(w&thinsp;f+2)* is
-  *-1/f mod 2<sup>2L</sup>*. This allows extending the previous formulas (or tables). In particular we
-  have this 6-bit function (based on the 3-bit function above):
-  - *f(f<sup>2</sup> - 2)*
-
-This loop, again extended to also handle *u*, *v*, *q*, and *r* alongside *f* and *g*, placed in
-`divsteps_n_matrix`, gives a significantly faster, but non-constant time version.
-
-
-## 7. Final Python version
-
-All together we need the following functions:
-
-- A way to compute the transition matrix in constant time, using the `divsteps_n_matrix` function
-  from section 2, but with its loop replaced by a variant of the constant-time divstep from
-  section 5, extended to handle *u*, *v*, *q*, *r*:
-
-```python
-def divsteps_n_matrix(zeta, f, g):
-    """Compute zeta and transition matrix t after N divsteps (multiplied by 2^N)."""
-    u, v, q, r = 1, 0, 0, 1 # start with identity matrix
-    for _ in range(N):
-        c1 = zeta >> 63
-        # Compute x, y, z as conditionally-negated versions of f, u, v.
-        x, y, z = (f ^ c1) - c1, (u ^ c1) - c1, (v ^ c1) - c1
-        c2 = -(g & 1)
-        # Conditionally add x, y, z to g, q, r.
-        g, q, r = g + (x & c2), q + (y & c2), r + (z & c2)
-        c1 &= c2                     # reusing c1 here for the earlier c3 variable
-        zeta = (zeta ^ c1) - 1       # inlining the unconditional zeta decrement here
-        # Conditionally add g, q, r to f, u, v.
-        f, u, v = f + (g & c1), u + (q & c1), v + (r & c1)
-        # When shifting g down, don't shift q, r, as we construct a transition matrix multiplied
-        # by 2^N. Instead, shift f's coefficients u and v up.
-        g, u, v = g >> 1, u << 1, v << 1
-    return zeta, (u, v, q, r)
-```
-
-- The functions to update *f* and *g*, and *d* and *e*, from section 2 and section 4, with the constant-time
-  changes to `update_de` from section 5:
-
-```python
-def update_fg(f, g, t):
-    """Multiply matrix t/2^N with [f, g]."""
-    u, v, q, r = t
-    cf, cg = u*f + v*g, q*f + r*g
-    return cf >> N, cg >> N
-
-def update_de(d, e, t, M, Mi):
-    """Multiply matrix t/2^N with [d, e], modulo M."""
-    u, v, q, r = t
-    d_sign, e_sign = d >> 257, e >> 257
-    md, me = (u & d_sign) + (v & e_sign), (q & d_sign) + (r & e_sign)
-    cd, ce = (u*d + v*e) % 2**N, (q*d + r*e) % 2**N
-    md -= (Mi*cd + md) % 2**N
-    me -= (Mi*ce + me) % 2**N
-    cd, ce = u*d + v*e + M*md, q*d + r*e + M*me
-    return cd >> N, ce >> N
-```
-
-- The `normalize` function from section 4, made constant time as well:
-
-```python
-def normalize(sign, v, M):
-    """Compute sign*v mod M, where v in (-2*M,M); output in [0,M)."""
-    v_sign = v >> 257
-    # Conditionally add M to v.
-    v += M & v_sign
-    c = (sign - 1) >> 1
-    # Conditionally negate v.
-    v = (v ^ c) - c
-    v_sign = v >> 257
-    # Conditionally add M to v again.
-    v += M & v_sign
-    return v
-```
-
-- And finally the `modinv` function too, adapted to use *&zeta;* instead of *&delta;*, and using the fixed
-  iteration count from section 5:
-
-```python
-def modinv(M, Mi, x):
-    """Compute the modular inverse of x mod M, given Mi=1/M mod 2^N."""
-    zeta, f, g, d, e = -1, M, x, 0, 1
-    for _ in range((590 + N - 1) // N):
-        zeta, t = divsteps_n_matrix(zeta, f % 2**N, g % 2**N)
-        f, g = update_fg(f, g, t)
-        d, e = update_de(d, e, t, M, Mi)
-    return normalize(f, d, M)
-```
-
-- To get a variable time version, replace the `divsteps_n_matrix` function with one that uses the
-  divsteps loop from section 5, and a `modinv` version that calls it without the fixed iteration
-  count:
-
-```python
-NEGINV16 = [15, 5, 3, 9, 7, 13, 11, 1] # NEGINV16[n//2] = (-n)^-1 mod 16, for odd n
-def divsteps_n_matrix_var(eta, f, g):
-    """Compute eta and transition matrix t after N divsteps (multiplied by 2^N)."""
-    u, v, q, r = 1, 0, 0, 1
-    i = N
-    while True:
-        zeros = min(i, count_trailing_zeros(g))
-        eta, i = eta - zeros, i - zeros
-        g, u, v = g >> zeros, u << zeros, v << zeros
-        if i == 0:
-            break
-        if eta < 0:
-            eta, f, u, v, g, q, r = -eta, g, q, r, -f, -u, -v
-        limit = min(min(eta + 1, i), 4)
-        w = (g * NEGINV16[(f & 15) // 2]) % (2**limit)
-        g, q, r = g + w*f, q + w*u, r + w*v
-    return eta, (u, v, q, r)
-
-def modinv_var(M, Mi, x):
-    """Compute the modular inverse of x mod M, given Mi = 1/M mod 2^N."""
-    eta, f, g, d, e = -1, M, x, 0, 1
-    while g != 0:
-        eta, t = divsteps_n_matrix_var(eta, f % 2**N, g % 2**N)
-        f, g = update_fg(f, g, t)
-        d, e = update_de(d, e, t, M, Mi)
-    return normalize(f, d, Mi)
-```
-
-## 8. From GCDs to Jacobi symbol
-
-We can also use a similar approach to calculate Jacobi symbol *(x | M)* by keeping track of an
-extra variable *j*, for which at every step *(x | M) = j (g | f)*. As we update *f* and *g*, we
-make corresponding updates to *j* using
-[properties of the Jacobi symbol](https://en.wikipedia.org/wiki/Jacobi_symbol#Properties):
-* *((g/2) | f)* is either *(g | f)* or *-(g | f)*, depending on the value of *f mod 8* (negating if it's *3* or *5*).
-* *(f | g)* is either *(g | f)* or *-(g | f)*, depending on *f mod 4* and *g mod 4* (negating if both are *3*).
-
-These updates depend only on the values of *f* and *g* modulo *4* or *8*, and can thus be applied
-very quickly, as long as we keep track of a few additional bits of *f* and *g*. Overall, this
-calculation is slightly simpler than the one for the modular inverse because we no longer need to
-keep track of *d* and *e*.
-
-However, one difficulty of this approach is that the Jacobi symbol *(a | n)* is only defined for
-positive odd integers *n*, whereas in the original safegcd algorithm, *f, g* can take negative
-values. We resolve this by using the following modified steps:
-
-```python
-        # Before
-        if delta > 0 and g & 1:
-            delta, f, g = 1 - delta, g, (g - f) // 2
-
-        # After
-        if delta > 0 and g & 1:
-            delta, f, g = 1 - delta, g, (g + f) // 2
-```
-
-The algorithm is still correct, since the changed divstep, called a "posdivstep" (see section 8.4
-and E.5 in the paper) preserves *gcd(f, g)*. However, there's no proof that the modified algorithm
-will converge. The justification for posdivsteps is completely empirical: in practice, it appears
-that the vast majority of nonzero inputs converge to *f=g=gcd(f<sub>0</sub>, g<sub>0</sub>)* in a
-number of steps proportional to their logarithm.
-
-Note that:
-- We require inputs to satisfy *gcd(x, M) = 1*, as otherwise *f=1* is not reached.
-- We require inputs *x &neq; 0*, because applying posdivstep with *g=0* has no effect.
-- We need to update the termination condition from *g=0* to *f=1*.
-
-We account for the possibility of nonconvergence by only performing a bounded number of
-posdivsteps, and then falling back to square-root based Jacobi calculation if a solution has not
-yet been found.
-
-The optimizations in sections 3-7 above are described in the context of the original divsteps, but
-in the C implementation we also adapt most of them (not including "avoiding modulus operations",
-since it's not necessary to track *d, e*, and "constant-time operation", since we never calculate
-Jacobi symbols for secret data) to the posdivsteps version.