half of hw threads for sweep

As part of import optimization, a transitive include had been removed that defined `BOOST_COMP_MSVC` on Windows. In unity builds, this definition was pulled in, but in non-unity builds it was not - causing a compilation error. An inspection of the Boost code revealed that we can just gate the statements by `_MS_VER` instead. A `#pragma message` is added to verify that the statement is only printed on Windows builds.

.clang-format

@@ -0,0 +1,96 @@
+---
+Language:        Cpp
+AccessModifierOffset: -4
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: true
+AlignOperands: false
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: All
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       false
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+BreakBeforeBinaryOperators: false
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+ForEachMacros:   [ Q_FOREACH,  BOOST_FOREACH ]
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^<(test)/'
+    Priority:        0
+  - Regex:           '^<(xrpld)/'
+    Priority:        1
+  - Regex:           '^<(xrpl)/'
+    Priority:        2
+  - Regex:           '^<(boost)/'
+    Priority:        3
+  - Regex:           '^.*/'
+    Priority:        4
+  - Regex:           '^.*\.h'
+    Priority:        5
+  - Regex:           '.*'
+    Priority:        6
+IncludeIsMainRegex: '$'
+IndentCaseLabels: true
+IndentFunctionDeclarationAfterType: false
+IndentRequiresClause: true
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+ReflowComments:  true
+RequiresClausePosition: OwnLine
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
+UseTab:          Never

.codecov.yml

@@ -1,6 +1,37 @@
-
 codecov:
-  ci:
-    - ci.ops.ripple.com  # add custom jenkins server
-    - !appveyor
-    - !travis
+  require_ci_to_pass: true
+
+comment:
+  behavior: default
+  layout: reach,diff,flags,tree,reach
+  show_carryforward_flags: false
+
+coverage:
+  range: "60..80"
+  precision: 1
+  round: nearest
+  status:
+    project:
+      default:
+        target: 60%
+        threshold: 2%
+    patch:
+      default:
+        target: auto
+        threshold: 2%
+    changes: false
+
+github_checks:
+  annotations: true
+
+parsers:
+  cobertura:
+    partials_as_hits: true
+    handle_missing_conditions : true
+
+slack_app: false
+
+ignore:
+  - "src/test/"
+  - "include/xrpl/beast/test/"
+  - "include/xrpl/beast/unit_test/"

.git-blame-ignore-revs

@@ -0,0 +1,13 @@
+# This feature requires Git >= 2.24
+# To use it by default in git blame:
+# git config blame.ignoreRevsFile .git-blame-ignore-revs
+50760c693510894ca368e90369b0cc2dabfd07f3
+e2384885f5f630c8f0ffe4bf21a169b433a16858
+241b9ddde9e11beb7480600fd5ed90e1ef109b21
+760f16f56835663d9286bd29294d074de26a7ba6
+0eebe6a5f4246fced516d52b83ec4e7f47373edd
+2189cc950c0cebb89e4e2fa3b2d8817205bf7cef
+b9d007813378ad0ff45660dc07285b823c7e9855
+fe9a5365b8a52d4acc42eb27369247e6f238a4f9
+9a93577314e6a8d4b4a8368cc9d2b15a5d8303e8
+552377c76f55b403a1c876df873a23d780fcc81c

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,31 @@
+---
+name: Bug Report
+about: Create a report to help us improve rippled
+title: "[Title with short description] (Version: [rippled version])"
+labels: ''
+assignees: ''
+
+---
+<!-- Please search existing issues to avoid creating duplicates.-->
+
+## Issue Description
+<!--Provide a summary for your issue/bug.-->
+
+## Steps to Reproduce
+<!--List in detail the exact steps to reproduce the unexpected behavior of the software.-->
+
+## Expected Result
+<!--Explain in detail what behavior you expected to happen.-->
+
+## Actual Result
+<!--Explain in detail what behavior actually happened.-->
+
+## Environment
+<!--Please describe your environment setup (such as Ubuntu 18.04 with Boost 1.70).-->
+<!-- If you are using a formal release, please use the version returned by './rippled --version' as the version number-->
+<!-- If you are working off of develop, please add the git hash via 'git rev-parse HEAD'-->
+
+## Supporting Files
+<!--If you have supporting files such as a log, feel free to post a link here using Github Gist.-->
+<!--Consider adding configuration files with private information removed via Github Gist. -->
+

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: XRP Ledger Documentation
+    url: https://xrpl.org/
+    about: All things about XRPL
+  - name: Security bug bounty program
+    url: https://ripple.com/bug-bounty/
+    about: Please report security-relevant bugs in our software here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,21 @@
+---
+name: Feature Request
+about: Suggest a new feature for the rippled project
+title: "[Title with short description] (Version: [rippled version])"
+labels: Feature Request
+assignees: ''
+
+---
+<!-- Please search existing issues to avoid creating duplicates.-->
+
+## Summary
+<!-- Provide a summary to the feature request-->
+
+## Motivation
+<!-- Why do we need this feature?-->
+
+## Solution
+<!-- What is the solution?-->
+
+## Paths Not Taken
+<!-- What other alternatives have been considered?-->

.github/actions/build/action.yml

@@ -0,0 +1,34 @@
+name: build
+inputs:
+  generator:
+    default: null
+  configuration:
+    required: true
+  cmake-args:
+    default: null
+  cmake-target:
+    default: all
+# An implicit input is the environment variable `build_dir`.
+runs:
+  using: composite
+  steps:
+    - name: configure
+      shell: bash
+      run: |
+        cd ${build_dir}
+        cmake \
+          ${{ inputs.generator && format('-G "{0}"', inputs.generator) || '' }} \
+          -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+          -DCMAKE_BUILD_TYPE=${{ inputs.configuration }} \
+          -Dtests=TRUE \
+          -Dxrpld=TRUE \
+          ${{ inputs.cmake-args }} \
+          ..
+    - name: build
+      shell: bash
+      run: |
+        cmake \
+          --build ${build_dir} \
+          --config ${{ inputs.configuration }} \
+          --parallel ${NUM_PROCESSORS:-$(nproc)} \
+          --target ${{ inputs.cmake-target }}

.github/actions/dependencies/action.yml

@@ -0,0 +1,57 @@
+name: dependencies
+inputs:
+  configuration:
+    required: true
+# An implicit input is the environment variable `build_dir`.
+runs:
+  using: composite
+  steps:
+    - name: unlock Conan
+      shell: bash
+      run: conan remove --locks
+    - name: export custom recipes
+      shell: bash
+      run: |
+        conan config set general.revisions_enabled=1
+        conan export external/snappy snappy/1.1.10@
+        conan export external/rocksdb rocksdb/9.7.3@
+        conan export external/soci soci/4.0.3@
+        conan export external/nudb nudb/2.0.8@
+    - name: add Ripple Conan remote
+      shell: bash
+      run: |
+        conan remote list
+        conan remote remove ripple || true
+        # Do not quote the URL. An empty string will be accepted (with
+        # a non-fatal warning), but a missing argument will not.
+        conan remote add ripple ${{ env.CONAN_URL }} --insert 0
+    - name: try to authenticate to Ripple Conan remote
+      id: remote
+      shell: bash
+      run: |
+        # `conan user` implicitly uses the environment variables
+        # CONAN_LOGIN_USERNAME_<REMOTE> and CONAN_PASSWORD_<REMOTE>.
+        # https://docs.conan.io/1/reference/commands/misc/user.html#using-environment-variables
+        # https://docs.conan.io/1/reference/env_vars.html#conan-login-username-conan-login-username-remote-name
+        # https://docs.conan.io/1/reference/env_vars.html#conan-password-conan-password-remote-name
+        echo outcome=$(conan user --remote ripple --password >&2 \
+          && echo success || echo failure) | tee ${GITHUB_OUTPUT}
+    - name: list missing binaries
+      id: binaries
+      shell: bash
+      # Print the list of dependencies that would need to be built locally.
+      # A non-empty list means we have "failed" to cache binaries remotely.
+      run: |
+        echo missing=$(conan info . --build missing --settings build_type=${{ inputs.configuration }} --json 2>/dev/null  | grep '^\[') | tee ${GITHUB_OUTPUT}
+    - name: install dependencies
+      shell: bash
+      run: |
+        mkdir ${build_dir}
+        cd ${build_dir}
+        conan install \
+          --output-folder . \
+          --build missing \
+          --options tests=True \
+          --options xrpld=True \
+          --settings build_type=${{ inputs.configuration }} \
+          ..

.github/pull_request_template.md

@@ -0,0 +1,85 @@
+<!--
+This PR template helps you to write a good pull request description.
+Please feel free to include additional useful information even beyond what is requested below.
+
+If your branch is on a personal fork and has a name that allows it to
+run CI build/test jobs (e.g. "ci/foo"), remember to rename it BEFORE
+opening the PR.  This avoids unnecessary redundant test runs. Renaming
+the branch after opening the PR will close the PR.
+https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-branches-in-your-repository/renaming-a-branch
+-->
+
+## High Level Overview of Change
+
+<!--
+Please include a summary of the changes.
+This may be a direct input to the release notes.
+If too broad, please consider splitting into multiple PRs.
+If a relevant task or issue, please link it here.
+-->
+
+### Context of Change
+
+<!--
+Please include the context of a change.
+If a bug fix, when was the bug introduced? What was the behavior?
+If a new feature, why was this architecture chosen? What were the alternatives?
+If a refactor, how is this better than the previous implementation?
+
+If there is a spec or design document for this feature, please link it here.
+-->
+
+### Type of Change
+
+<!--
+Please check [x] relevant options, delete irrelevant ones.
+-->
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] 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)
+- [ ] Release
+
+### API Impact
+
+<!--
+Please check [x] relevant options, delete irrelevant ones.
+
+* If there is any impact to the public API methods (HTTP / WebSocket), please update https://github.com/xrplf/rippled/blob/develop/API-CHANGELOG.md
+  * Update API-CHANGELOG.md and add the change directly in this PR by pushing to your PR branch.
+* libxrpl: See https://github.com/XRPLF/rippled/blob/develop/docs/build/depend.md
+* Peer Protocol: See https://xrpl.org/peer-protocol.html
+-->
+
+- [ ] Public API: New feature (new methods and/or new fields)
+- [ ] Public API: Breaking change (in general, breaking changes should only impact the next api_version)
+- [ ] `libxrpl` change (any change that may affect `libxrpl` or dependents of `libxrpl`)
+- [ ] Peer protocol change (must be backward compatible or bump the peer protocol version)
+
+<!--
+## 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?
+-->
+
+<!--
+## Test Plan
+If helpful, please describe the tests that you ran to verify your changes and provide instructions so that others can reproduce.
+This section may not be needed if your change includes thoroughly commented unit tests.
+-->
+
+<!--
+## Future Tasks
+For future tasks related to PR.
+-->

.github/workflows/clang-format.yml

@@ -0,0 +1,59 @@
+name: clang-format
+
+on: [push, pull_request]
+
+jobs:
+  check:
+    runs-on: ubuntu-24.04
+    env:
+      CLANG_VERSION: 18
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install clang-format
+        run: |
+          codename=$( lsb_release --codename --short )
+          sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
+          deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
+          deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
+          EOF
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
+          sudo apt-get update
+          sudo apt-get install clang-format-${CLANG_VERSION}
+      - name: Format first-party sources
+        run: find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
+      - name: Check for differences
+        id: assert
+        run: |
+          set -o pipefail
+          git diff --exit-code | tee "clang-format.patch"
+      - name: Upload patch
+        if: failure() && steps.assert.outcome == 'failure'
+        uses: actions/upload-artifact@v4
+        continue-on-error: true
+        with:
+          name: clang-format.patch
+          if-no-files-found: ignore
+          path: clang-format.patch
+      - name: What happened?
+        if: failure() && steps.assert.outcome == 'failure'
+        env:
+          PREAMBLE: |
+            If you are reading this, you are looking at a failed Github Actions
+            job.  That means you pushed one or more files that did not conform
+            to the formatting specified in .clang-format. That may be because
+            you neglected to run 'git clang-format' or 'clang-format' before
+            committing, or that your version of clang-format has an
+            incompatibility with the one on this
+            machine, which is:
+          SUGGESTION: |
+
+            To fix it, you can do one of two things:
+            1. Download and apply the patch generated as an artifact of this
+               job to your repo, commit, and push.
+            2. Run 'git-clang-format --extensions cpp,h,hpp,ipp develop'
+               in your repo, commit, and push.
+        run: |
+          echo "${PREAMBLE}"
+          clang-format-${CLANG_VERSION} --version
+          echo "${SUGGESTION}"
+          exit 1

.github/workflows/doxygen.yml

@@ -0,0 +1,37 @@
+name: Build and publish Doxygen documentation
+# To test this workflow, push your changes to your fork's `develop` branch.
+on:
+  push:
+    branches:
+      - develop
+      - doxygen
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  job:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: check environment
+        run: |
+          echo ${PATH} | tr ':' '\n'
+          cmake --version
+          doxygen --version
+          env | sort
+      - name: build
+        run: |
+          mkdir build
+          cd build
+          cmake -Donly_docs=TRUE ..
+          cmake --build . --target docs --parallel $(nproc)
+      - name: publish
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: build/docs/html

.github/workflows/levelization.yml

@@ -0,0 +1,49 @@
+name: levelization
+
+on: [push, pull_request]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    env:
+      CLANG_VERSION: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Check levelization
+        run: Builds/levelization/levelization.sh
+      - name: Check for differences
+        id: assert
+        run: |
+          set -o pipefail
+          git diff --exit-code | tee "levelization.patch"
+      - name: Upload patch
+        if: failure() && steps.assert.outcome == 'failure'
+        uses: actions/upload-artifact@v4
+        continue-on-error: true
+        with:
+          name: levelization.patch
+          if-no-files-found: ignore
+          path: levelization.patch
+      - name: What happened?
+        if: failure() && steps.assert.outcome == 'failure'
+        env:
+          MESSAGE: |
+            If you are reading this, you are looking at a failed Github
+            Actions job. That means you changed the dependency relationships
+            between the modules in rippled. That may be an improvement or a
+            regression. This check doesn't judge.
+
+            A rule of thumb, though, is that if your changes caused
+            something to be removed from loops.txt, that's probably an
+            improvement. If something was added, it's probably a regression.
+
+            To fix it, you can do one of two things:
+            1. Download and apply the patch generated as an artifact of this
+               job to your repo, commit, and push.
+            2. Run './Builds/levelization/levelization.sh' in your repo,
+               commit, and push.
+
+            See Builds/levelization/README.md for more info.
+        run: |
+          echo "${MESSAGE}"
+          exit 1

.github/workflows/libxrpl.yml

@@ -0,0 +1,89 @@
+name: Check libXRPL compatibility with Clio
+env:
+  CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+  CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+  CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
+on:
+  pull_request:
+    paths:
+      - 'src/libxrpl/protocol/BuildInfo.cpp'
+      - '.github/workflows/libxrpl.yml'
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  publish:
+    name: Publish libXRPL
+    outputs:
+      outcome: ${{ steps.upload.outputs.outcome }}
+      version: ${{ steps.version.outputs.version }}
+      channel: ${{ steps.channel.outputs.channel }}
+    runs-on: [self-hosted, heavy]
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    steps:
+      - name: Wait for essential checks to succeed
+        uses: lewagon/wait-on-check-action@v1.3.4
+        with:
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
+          running-workflow-name: wait-for-check-regexp
+          check-regexp: '(dependencies|test).*linux.*' # Ignore windows and mac tests but make sure linux passes
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          wait-interval: 10
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Generate channel
+        id: channel
+        shell: bash
+        run: |
+          echo channel="clio/pr_${{ github.event.pull_request.number }}" | tee ${GITHUB_OUTPUT}
+      - name: Export new package
+        shell: bash
+        run: |
+          conan export . ${{ steps.channel.outputs.channel }}
+      - name: Add Ripple Conan remote
+        shell: bash
+        run: |
+          conan remote list
+          conan remote remove ripple || true
+          # Do not quote the URL. An empty string will be accepted (with a non-fatal warning), but a missing argument will not.
+          conan remote add ripple ${{ env.CONAN_URL }} --insert 0
+      - name: Parse new version
+        id: version
+        shell: bash
+        run: |
+          echo version="$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" \
+            | awk -F '"' '{print $2}')" | tee ${GITHUB_OUTPUT}
+      - name: Try to authenticate to Ripple Conan remote
+        id: remote
+        shell: bash
+        run: |
+          # `conan user` implicitly uses the environment variables CONAN_LOGIN_USERNAME_<REMOTE> and CONAN_PASSWORD_<REMOTE>.
+          # https://docs.conan.io/1/reference/commands/misc/user.html#using-environment-variables
+          # https://docs.conan.io/1/reference/env_vars.html#conan-login-username-conan-login-username-remote-name
+          # https://docs.conan.io/1/reference/env_vars.html#conan-password-conan-password-remote-name
+          echo outcome=$(conan user --remote ripple --password >&2 \
+            && echo success || echo failure) | tee ${GITHUB_OUTPUT}
+      - name: Upload new package
+        id: upload
+        if: (steps.remote.outputs.outcome == 'success')
+        shell: bash
+        run: |
+          echo "conan upload version ${{ steps.version.outputs.version }} on channel ${{ steps.channel.outputs.channel }}"
+          echo outcome=$(conan upload xrpl/${{ steps.version.outputs.version }}@${{ steps.channel.outputs.channel }} --remote ripple --confirm >&2 \
+            && echo success || echo failure) | tee ${GITHUB_OUTPUT}
+  notify_clio:
+    name: Notify Clio
+    runs-on: ubuntu-latest
+    needs: publish
+    env:
+      GH_TOKEN: ${{ secrets.CLIO_NOTIFY_TOKEN }}
+    steps:
+      - name: Notify Clio about new version
+        if: (needs.publish.outputs.outcome == 'success')
+        shell: bash
+        run: |
+          gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
+          /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
+          -F "client_payload[version]=${{ needs.publish.outputs.version }}@${{ needs.publish.outputs.channel }}" \
+          -F "client_payload[pr]=${{ github.event.pull_request.number }}"

.github/workflows/macos.yml

@@ -0,0 +1,94 @@
+name: macos
+on:
+  pull_request:
+  push:
+    # If the branches list is ever changed, be sure to change it on all
+    # build/test jobs (nix, macos, windows, instrumentation)
+    branches:
+      # Always build the package branches
+      - develop
+      - release
+      - master
+      # Branches that opt-in to running
+      - 'ci/**'
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  test:
+    strategy:
+      matrix:
+        platform:
+          - macos
+        generator:
+          - Ninja
+        configuration:
+          - Release
+    runs-on: [self-hosted, macOS]
+    env:
+      # The `build` action requires these variables.
+      build_dir: .build
+      NUM_PROCESSORS: 12
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: install Conan
+        run: |
+          brew install conan@1
+          echo '/opt/homebrew/opt/conan@1/bin' >> $GITHUB_PATH
+      - name: install Ninja
+        if: matrix.generator == 'Ninja'
+        run: brew install ninja
+      - name: install python
+        run: | 
+          if which python > /dev/null 2>&1; then
+              echo "Python executable exists"
+          else
+              brew install python@3.13
+              ln -s /opt/homebrew/bin/python3 /opt/homebrew/bin/python
+          fi
+      - name: install cmake
+        run: |
+          if which cmake > /dev/null 2>&1; then
+              echo "cmake executable exists"
+          else
+              brew install cmake
+          fi
+      - name: install nproc
+        run: |
+          brew install coreutils
+      - name: check environment
+        run: |
+          env | sort
+          echo ${PATH} | tr ':' '\n'
+          python --version
+          conan --version
+          cmake --version
+          nproc --version
+          echo -n "nproc returns: "
+          nproc
+      - name: configure Conan
+        run : |
+          conan profile new default --detect || true
+          conan profile update settings.compiler.cppstd=20 default
+      - name: build dependencies
+        uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: ${{ matrix.generator }}
+          configuration: ${{ matrix.configuration }}
+          cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
+      - name: test
+        run: |
+          n=$(nproc)
+          echo "Using $n test jobs"
+          ${build_dir}/rippled --unittest --unittest-jobs $n

.github/workflows/missing-commits.yml

@@ -0,0 +1,60 @@
+name: missing-commits
+
+on:
+  push:
+    branches:
+      # Only check that the branches are up to date when updating the
+      # relevant branches.
+      - develop
+      - release
+
+jobs:
+  up_to_date:
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Check for missing commits
+      id: commits
+      env:
+        SUGGESTION: |
+
+          If you are reading this, then the commits indicated above are
+          missing from "develop" and/or "release". Do a reverse-merge
+          as soon as possible. See CONTRIBUTING.md for instructions.
+      run: |
+        set -o pipefail
+        # Branches ordered by how "canonical" they are. Every commit in
+        # one branch should be in all the branches behind it
+        order=( master release develop )
+        branches=()
+        for branch in "${order[@]}"
+        do
+          # Check that the branches exist so that this job will work on
+          # forked repos, which don't necessarily have master and
+          # release branches.
+          if git ls-remote --exit-code --heads origin \
+            refs/heads/${branch} > /dev/null
+          then
+            branches+=( origin/${branch} )
+          fi
+        done
+
+        prior=()
+        for branch in "${branches[@]}"
+        do
+          if [[ ${#prior[@]} -ne 0 ]]
+          then
+            echo "Checking ${prior[@]} for commits missing from ${branch}"
+            git log --oneline --no-merges "${prior[@]}" \
+              ^$branch | tee -a "missing-commits.txt"
+            echo
+          fi
+          prior+=( "${branch}" )
+        done
+        if [[ $( cat missing-commits.txt | wc -l ) -ne 0 ]]
+        then
+          echo "${SUGGESTION}"
+          exit 1
+        fi

.github/workflows/nix.yml

@@ -0,0 +1,440 @@
+name: nix
+on:
+  pull_request:
+  push:
+    # If the branches list is ever changed, be sure to change it on all
+    # build/test jobs (nix, macos, windows)
+    branches:
+      # Always build the package branches
+      - develop
+      - release
+      - master
+      # Branches that opt-in to running
+      - "ci/**"
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+# This workflow has multiple job matrixes.
+# They can be considered phases because most of the matrices ("test",
+# "coverage", "conan", ) depend on the first ("dependencies").
+#
+# The first phase has a job in the matrix for each combination of
+# variables that affects dependency ABI:
+# platform, compiler, and configuration.
+# It creates a GitHub artifact holding the Conan profile,
+# and builds and caches binaries for all the dependencies.
+# If an Artifactory remote is configured, they are cached there.
+# If not, they are added to the GitHub artifact.
+# GitHub's "cache" action has a size limit (10 GB) that is too small
+# to hold the binaries if they are built locally.
+# We must use the "{upload,download}-artifact" actions instead.
+#
+# The remaining phases have a job in the matrix for each test
+# configuration. They install dependency binaries from the cache,
+# whichever was used, and build and test rippled.
+#
+# "instrumentation" is independent, but is included here because it also
+# builds on linux in the same "on:" conditions.
+
+jobs:
+  dependencies:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - linux
+        compiler:
+          - gcc
+          - clang
+        configuration:
+          - Debug
+          - Release
+        include:
+          - compiler: gcc
+            profile:
+              version: 11
+              cc: /usr/bin/gcc
+              cxx: /usr/bin/g++
+          - compiler: clang
+            profile:
+              version: 14
+              cc: /usr/bin/clang-14
+              cxx: /usr/bin/clang++-14
+    runs-on: [self-hosted, heavy]
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    env:
+      build_dir: .build
+    steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: check environment
+        run: |
+          echo ${PATH} | tr ':' '\n'
+          lsb_release -a || true
+          ${{ matrix.profile.cc }} --version
+          conan --version
+          cmake --version
+          env | sort
+      - name: configure Conan
+        run: |
+          conan profile new default --detect
+          conan profile update settings.compiler.cppstd=20 default
+          conan profile update settings.compiler=${{ matrix.compiler }} default
+          conan profile update settings.compiler.version=${{ matrix.profile.version }} default
+          conan profile update settings.compiler.libcxx=libstdc++11 default
+          conan profile update env.CC=${{ matrix.profile.cc }} default
+          conan profile update env.CXX=${{ matrix.profile.cxx }} default
+          conan profile update conf.tools.build:compiler_executables='{"c": "${{ matrix.profile.cc }}", "cpp": "${{ matrix.profile.cxx }}"}' default
+      - name: archive profile
+        # Create this archive before dependencies are added to the local cache.
+        run: tar -czf conan.tar -C ~/.conan .
+      - name: build dependencies
+        uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: upload archive
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
+          path: conan.tar
+          if-no-files-found: error
+
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - linux
+        compiler:
+          - gcc
+          - clang
+        configuration:
+          - Debug
+          - Release
+        cmake-args:
+          -
+          - "-Dunity=ON"
+    needs: dependencies
+    runs-on: [self-hosted, heavy]
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    env:
+      build_dir: .build
+    steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
+      - name: download cache
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
+      - name: extract cache
+        run: |
+          mkdir -p ~/.conan
+          tar -xzf conan.tar -C ~/.conan
+      - name: check environment
+        run: |
+          env | sort
+          echo ${PATH} | tr ':' '\n'
+          conan --version
+          cmake --version
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
+      - name: test
+        run: |
+          ${build_dir}/rippled --unittest --unittest-jobs $(nproc)
+
+  reference-fee-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - linux
+        compiler:
+          - gcc
+        configuration:
+          - Debug
+        cmake-args:
+          - "-DUNIT_TEST_REFERENCE_FEE=200"
+          - "-DUNIT_TEST_REFERENCE_FEE=1000"
+    needs: dependencies
+    runs-on: [self-hosted, heavy]
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    env:
+      build_dir: .build
+    steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
+      - name: download cache
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
+      - name: extract cache
+        run: |
+          mkdir -p ~/.conan
+          tar -xzf conan.tar -C ~/.conan
+      - name: check environment
+        run: |
+          env | sort
+          echo ${PATH} | tr ':' '\n'
+          conan --version
+          cmake --version
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
+      - name: test
+        run: |
+          ${build_dir}/rippled --unittest --unittest-jobs $(nproc)
+
+  coverage:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - linux
+        compiler:
+          - gcc
+        configuration:
+          - Debug
+    needs: dependencies
+    runs-on: [self-hosted, heavy]
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    env:
+      build_dir: .build
+    steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
+      - name: download cache
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
+      - name: extract cache
+        run: |
+          mkdir -p ~/.conan
+          tar -xzf conan.tar -C ~/.conan
+      - name: install gcovr
+        run: pip install "gcovr>=7,<8"
+      - name: check environment
+        run: |
+          echo ${PATH} | tr ':' '\n'
+          conan --version
+          cmake --version
+          gcovr --version
+          env | sort
+          ls ~/.conan
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          cmake-args: >-
+            -Dassert=TRUE
+            -Dwerr=TRUE
+            -Dcoverage=ON
+            -Dcoverage_format=xml
+            -DCODE_COVERAGE_VERBOSE=ON
+            -DCMAKE_CXX_FLAGS="-O0"
+            -DCMAKE_C_FLAGS="-O0"
+          cmake-target: coverage
+      - name: move coverage report
+        shell: bash
+        run: |
+          mv "${build_dir}/coverage.xml" ./
+      - name: archive coverage report
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage.xml
+          path: coverage.xml
+          retention-days: 30
+      - name: upload coverage report
+        uses: wandalen/wretry.action@v1.4.10
+        with:
+          action: codecov/codecov-action@v4.5.0
+          with: |
+            files: coverage.xml
+            fail_ci_if_error: true
+            disable_search: true
+            verbose: true
+            plugin: noop
+            token: ${{ secrets.CODECOV_TOKEN }}
+          attempt_limit: 5
+          attempt_delay: 210000 # in milliseconds
+
+  conan:
+    needs: dependencies
+    runs-on: [self-hosted, heavy]
+    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    env:
+      build_dir: .build
+      configuration: Release
+    steps:
+      - name: upgrade conan
+        run: |
+          pip install --upgrade "conan<2"
+      - name: download cache
+        uses: actions/download-artifact@v4
+        with:
+          name: linux-gcc-${{ env.configuration }}
+      - name: extract cache
+        run: |
+          mkdir -p ~/.conan
+          tar -xzf conan.tar -C ~/.conan
+      - name: check environment
+        run: |
+          env | sort
+          echo ${PATH} | tr ':' '\n'
+          conan --version
+          cmake --version
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+        with:
+          configuration: ${{ env.configuration }}
+      - name: export
+        run: |
+          version=$(conan inspect --raw version .)
+          reference="xrpl/${version}@local/test"
+          conan remove -f ${reference} || true
+          conan export . local/test
+          echo "reference=${reference}" >> "${GITHUB_ENV}"
+      - name: build
+        run: |
+          cd tests/conan
+          mkdir ${build_dir}
+          cd ${build_dir}
+          conan install .. --output-folder . \
+            --require-override ${reference} --build missing
+          cmake .. \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=./build/${configuration}/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE=${configuration}
+          cmake --build .
+          ./example | grep '^[[:digit:]]\+\.[[:digit:]]\+\.[[:digit:]]\+'
+
+  # NOTE we are not using dependencies built above because it lags with
+  # compiler versions. Instrumentation requires clang version 16 or
+  # later
+
+  instrumentation-build:
+    env:
+      CLANG_RELEASE: 16
+    strategy:
+      fail-fast: false
+    runs-on: [self-hosted, heavy]
+    container: debian:bookworm
+    steps:
+        - name: install prerequisites
+          env:
+            DEBIAN_FRONTEND: noninteractive
+          run: |
+            apt-get update
+            apt-get install --yes --no-install-recommends \
+              clang-${CLANG_RELEASE} clang++-${CLANG_RELEASE} \
+              python3-pip python-is-python3 make cmake git wget
+            apt-get clean
+            update-alternatives --install \
+              /usr/bin/clang clang /usr/bin/clang-${CLANG_RELEASE} 100 \
+              --slave /usr/bin/clang++ clang++ /usr/bin/clang++-${CLANG_RELEASE}
+            update-alternatives --auto clang
+            pip install --no-cache --break-system-packages "conan<2"
+
+        - name: checkout
+          uses: actions/checkout@v4
+
+        - name: prepare environment
+          run: |
+            mkdir ${GITHUB_WORKSPACE}/.build
+            echo "SOURCE_DIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+            echo "BUILD_DIR=$GITHUB_WORKSPACE/.build" >> $GITHUB_ENV
+            echo "CC=/usr/bin/clang" >> $GITHUB_ENV
+            echo "CXX=/usr/bin/clang++" >> $GITHUB_ENV
+
+        - name: configure Conan
+          run: |
+            conan profile new --detect default
+            conan profile update settings.compiler=clang default
+            conan profile update settings.compiler.version=${CLANG_RELEASE} default
+            conan profile update settings.compiler.libcxx=libstdc++11 default
+            conan profile update settings.compiler.cppstd=20 default
+            conan profile update options.rocksdb=False default
+            conan profile update \
+              'conf.tools.build:compiler_executables={"c": "/usr/bin/clang", "cpp": "/usr/bin/clang++"}' default
+            conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
+            conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
+            conan export external/snappy snappy/1.1.10@
+            conan export external/soci soci/4.0.3@
+
+        - name: build dependencies
+          run: |
+            cd ${BUILD_DIR}
+            conan install ${SOURCE_DIR} \
+              --output-folder ${BUILD_DIR} \
+              --install-folder ${BUILD_DIR} \
+              --build missing \
+              --settings build_type=Debug
+
+        - name: build with instrumentation
+          run: |
+            cd ${BUILD_DIR}
+            cmake -S ${SOURCE_DIR} -B ${BUILD_DIR} \
+              -Dvoidstar=ON \
+              -Dtests=ON \
+              -Dxrpld=ON \
+              -DCMAKE_BUILD_TYPE=Debug \
+              -DSECP256K1_BUILD_BENCHMARK=OFF \
+              -DSECP256K1_BUILD_TESTS=OFF \
+              -DSECP256K1_BUILD_EXHAUSTIVE_TESTS=OFF \
+              -DCMAKE_TOOLCHAIN_FILE=${BUILD_DIR}/build/generators/conan_toolchain.cmake
+            cmake --build .  --parallel $(nproc)
+
+        - name: verify instrumentation enabled
+          run: |
+            cd ${BUILD_DIR}
+            ./rippled --version | grep libvoidstar
+
+        - name: run unit tests
+          run: |
+            cd ${BUILD_DIR}
+            ./rippled -u --unittest-jobs $(( $(nproc)/4 ))

.github/workflows/windows.yml

@@ -0,0 +1,97 @@
+name: windows
+
+on:
+  pull_request:
+  push:
+    # If the branches list is ever changed, be sure to change it on all
+    # build/test jobs (nix, macos, windows, instrumentation)
+    branches:
+      # Always build the package branches
+      - develop
+      - release
+      - master
+      # Branches that opt-in to running
+      - 'ci/**'
+
+# https://docs.github.com/en/actions/using-jobs/using-concurrency
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - generator: Visual Studio 17 2022
+            runs-on: windows-2022
+        configuration:
+          - type: Release
+            tests: true
+          - type: Debug
+            # Skip running unit tests on debug builds, because they
+            # take an unreasonable amount of time
+            tests: false
+            runtime: d
+    runs-on: ${{ matrix.version.runs-on }}
+    env:
+      build_dir: .build
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: choose Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.9
+      - name: learn Python cache directory
+        id: pip-cache
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          echo "dir=$(pip cache dir)" | tee ${GITHUB_OUTPUT}
+      - name: restore Python cache directory
+        uses: actions/cache@v4
+        with:
+            path: ${{ steps.pip-cache.outputs.dir }}
+            key: ${{ runner.os }}-${{ hashFiles('.github/workflows/windows.yml') }}
+      - name: install Conan
+        run: pip install wheel 'conan<2'
+      - name: check environment
+        run: |
+          dir env:
+          $env:PATH -split ';'
+          python --version
+          conan --version
+          cmake --version
+      - name: configure Conan
+        shell: bash
+        run: |
+          conan profile new default --detect
+          conan profile update settings.compiler.cppstd=20 default
+          conan profile update \
+            settings.compiler.runtime=MT${{ matrix.configuration.runtime }} \
+            default
+      - name: build dependencies
+        uses: ./.github/actions/dependencies
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
+        with:
+          configuration: ${{ matrix.configuration.type }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: '${{ matrix.version.generator }}'
+          configuration: ${{ matrix.configuration.type }}
+          # Hard code for now. Move to the matrix if varied options are needed
+          cmake-args: '-Dassert=TRUE -Dwerr=TRUE -Dreporting=OFF -Dunity=ON'
+          cmake-target: install
+      - name: test
+        shell: bash
+        if: ${{ matrix.configuration.tests }}
+        run: |
+          ${build_dir}/${{ matrix.configuration.type }}/rippled --unittest \
+              --unittest-jobs $(nproc)

.gitignore

@@ -21,9 +21,12 @@ bin/project-cache.jam
 
 # Ignore object files.
 *.o
-build
+.nih_c
 tags
 TAGS
+GTAGS
+GRTAGS
+GPATH
 bin/rippled
 Debug/*.*
 Release/*.*
@@ -33,6 +36,12 @@ Release/*.*
 *.gcda
 *.gcov
 
+# Levelization checking
+Builds/levelization/results/rawincludes.txt
+Builds/levelization/results/paths.txt
+Builds/levelization/results/includes/
+Builds/levelization/results/includedby/
+
 # Ignore tmp directory.
 tmp
 
@@ -55,7 +64,7 @@ docs/html_doc
 # Xcode user-specific project settings
 # Xcode
 .DS_Store
-*/build/*
+/build/
 *.pbxuser
 !default.pbxuser
 *.mode1v3
@@ -91,3 +100,15 @@ Builds/VisualStudio2015/*.sdf
 # MSVC
 *.pdb
 .vs/
+CMakeSettings.json
+compile_commands.json
+.clangd
+packages
+pkg_out
+pkg
+CMakeUserPresets.json
+bld.rippled/
+.vscode
+
+# Suggested in-tree build directory
+/.build/

.gitmodules

@@ -1,9 +0,0 @@
-[submodule "src/nudb/extras/beast"]
-	path = src/nudb/extras/beast
-	url = https://github.com/vinniefalco/Beast.git
-[submodule "src/nudb/extras/rocksdb"]
-	path = src/nudb/extras/rocksdb
-	url = https://github.com/facebook/rocksdb.git
-[submodule "src/nudb/doc/docca"]
-	path = src/nudb/doc/docca
-	url = https://github.com/vinniefalco/docca.git

.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+# .pre-commit-config.yaml
+repos:
+- repo: https://github.com/pre-commit/mirrors-clang-format
+  rev: v18.1.3
+  hooks:
+  - id: clang-format

.travis.yml

@@ -1,75 +0,0 @@
-sudo: false
-language: cpp
-
-env:
-  global:
-    # Maintenance note: to move to a new version
-    # of boost, update both BOOST_ROOT and BOOST_URL.
-    # Note that for simplicity, BOOST_ROOT's final
-    # namepart must match the folder name internal
-    # to boost's .tar.gz.
-    - BOOST_ROOT=$HOME/boost_1_65_1
-    - BOOST_URL='https://dl.bintray.com/boostorg/release/1.65.1/source/boost_1_65_1.tar.gz'
-
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-trusty-5.0
-    packages:
-      - gcc-5
-      - g++-5
-      - python-software-properties
-      - protobuf-compiler
-      - libprotobuf-dev
-      - libssl-dev
-      - libstdc++6
-      - binutils-gold
-      - cmake
-      - lcov
-      - llvm-5.0
-      - clang-5.0
-
-matrix:
-  include:
-
-    - compiler: gcc
-      env: GCC_VER=5 TARGET=debug
-      # - APP_ARGS="--unittest-jobs=2"
-
-    # - compiler: gcc
-    #   env: GCC_VER=5 TARGET=debug.nounity
-
-    # - compiler: gcc
-    #   env: GCC_VER=5 TARGET=coverage PATH=$PWD/cmake/bin:$PATH
-
-    - compiler: clang
-      env: GCC_VER=5 TARGET=debug
-
-    # - compiler: clang
-    #   env: GCC_VER=5 TARGET=debug.nounity
-
-    # The clang cmake builds do not link.
-    # - compiler: clang
-    #   env: GCC_VER=5  TARGET=debug CLANG_VER=3.8 PATH=$PWD/llvm-$LLVM_VERSION/bin:$PWD/cmake/bin:$PATH
-
-    # - compiler: clang
-    #   env: GCC_VER=5 TARGET=debug.nounity CLANG_VER=3.8 PATH=$PWD/llvm-$LLVM_VERSION/bin:$PWD/cmake/bin:$PATH
-
-cache:
-  directories:
-  - $BOOST_ROOT
-
-before_install:
-  - bin/ci/ubuntu/install-dependencies.sh
-
-script:
-  - travis_retry bin/ci/ubuntu/build-and-test.sh
-
-notifications:
-  email:
-    false
-  irc:
-    channels:
-      - "chat.freenode.net#ripple-dev"
-

API-CHANGELOG.md

@@ -0,0 +1,217 @@
+# 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 2
+
+API version 2 is available in `rippled` version 2.0.0 and later. To use this API, clients specify `"api_version" : 2` in each request.
+
+#### 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)
+
+## API Version 1
+
+This version is supported by all `rippled` versions. For WebSocket and HTTP JSON-RPC requests, it is currently the default API version used when no `api_version` is specified.
+
+The [commandline](https://xrpl.org/docs/references/http-websocket-apis/api-conventions/request-formatting/#commandline-format) always uses 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.
+
+### Inconsistency: 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). However, use of reporting mode is now discouraged, in favor of using [Clio](https://github.com/XRPLF/clio) instead.
+
+## XRP Ledger server version 2.4.0
+
+As of 2025-01-28, version 2.4.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
+
+### Additions and bugfixes in 2.4.0
+
+- `ledger_entry`: `state` is added an alias for `ripple_state`.
+- `ledger_entry`: Enables case-insensitive filtering by canonical name in addition to case-sensitive filtering by RPC name.
+- `validators`: Added new field `validator_list_threshold` in response.
+- `simulate`: A new RPC that executes a [dry run of a transaction submission](https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0069d-simulate#2-rpc-simulate)
+- Signing methods autofill fees better and properly handle transactions that don't have a base fee, and will also autofill the `NetworkID` field.
+
+## XRP Ledger server version 2.3.0
+
+[Version 2.3.0](https://github.com/XRPLF/rippled/releases/tag/2.3.0) was released on Nov 25, 2024.
+
+### Breaking changes in 2.3.0
+
+- `book_changes`: If the requested ledger version is not available on this node, a `ledgerNotFound` error is returned and the node does not attempt to acquire the ledger from the p2p network (as with other non-admin RPCs).
+
+Admins can still attempt to retrieve old ledgers with the `ledger_request` RPC.
+
+### Additions and bugfixes in 2.3.0
+
+- `book_changes`: Returns a `validated` field in its response, which was missing in prior versions.
+
+## XRP Ledger server version 2.2.0
+
+[Version 2.2.0](https://github.com/XRPLF/rippled/releases/tag/2.2.0) was released on Jun 5, 2024. The following additions are non-breaking (because they are purely additive):
+
+- The `feature` method now has a non-admin mode for users. (It was previously only available to admin connections.) The method returns an updated list of amendments, including their names and other information. ([#4781](https://github.com/XRPLF/rippled/pull/4781))
+
+## XRP Ledger server version 2.0.0
+
+[Version 2.0.0](https://github.com/XRPLF/rippled/releases/tag/2.0.0) was released on Jan 9, 2024. The following additions are 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 2.2.0
+
+The following is a non-breaking addition to the API.
+
+- The `feature` method now has a non-admin mode for users. (It was previously only available to admin connections.) The method returns an updated list of amendments, including their names and other information. ([#4781](https://github.com/XRPLF/rippled/pull/4781))
+
+## 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. The following additions are 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.
+
+# 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

@@ -0,0 +1,500 @@
+| :warning: **WARNING** :warning:
+|---|
+| These instructions assume you have a C++ development environment ready with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up on Linux, macOS, or Windows, [see this guide](./docs/build/environment.md). |
+
+> These instructions also assume a basic familiarity with Conan and CMake.
+> If you are unfamiliar with Conan,
+> you can read our [crash course](./docs/build/conan.md)
+> or the official [Getting Started][3] walkthrough.
+
+## Branches
+
+For a stable release, choose the `master` branch or one of the [tagged
+releases](https://github.com/ripple/rippled/releases).
+
+```
+git checkout master
+```
+
+For the latest release candidate, choose the `release` branch.
+
+```
+git checkout release
+```
+
+For the latest set of untested features, or to contribute, choose the `develop`
+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.60](https://conan.io/downloads.html)[^1]
+- [CMake 3.16](https://cmake.org/download/)
+
+[^1]: It is possible to build with Conan 2.x,
+but the instructions are significantly different,
+which is why we are not recommending it yet.
+Notably, the `conan profile update` command is removed in 2.x.
+Profiles must be edited by hand.
+
+`rippled` is written in the C++20 dialect and includes the `<concepts>` header.
+The [minimum compiler versions][2] required are:
+
+| Compiler    | Version |
+|-------------|---------|
+| GCC         | 11      |
+| Clang       | 13      |
+| Apple Clang | 13.1.6  |
+| MSVC        | 19.23   |
+
+### Linux
+
+The Ubuntu operating system has received the highest level of
+quality assurance, testing, and support.
+
+Here are [sample instructions for setting up a C++ development environment on Linux](./docs/build/environment.md#linux).
+
+### Mac
+
+Many rippled engineers use macOS for development.
+
+Here are [sample instructions for setting up a C++ development environment on macOS](./docs/build/environment.md#macos).
+
+### Windows
+
+Windows is not recommended for production use at this time.
+
+- Additionally, 32-bit Windows development is not supported.
+
+[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:
+
+   ```
+   conan profile new default --detect
+   ```
+
+Update the compiler settings:
+
+   ```
+   conan profile update settings.compiler.cppstd=20 default
+   ```
+
+Configure Conan (1.x only) to use recipe revisions:
+
+   ```
+   conan config set general.revisions_enabled=1
+   ```
+
+**Linux** developers will commonly have a default Conan [profile][] that compiles
+with GCC and links with libstdc++.
+If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
+then you will need to choose the `libstdc++11` ABI:
+
+   ```
+   conan profile update settings.compiler.libcxx=libstdc++11 default
+   ```
+
+
+Ensure inter-operability between `boost::string_view` and `std::string_view` types:
+
+```
+conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_BEAST_USE_STD_STRING_VIEW"]' default
+conan profile update 'env.CXXFLAGS="-DBOOST_BEAST_USE_STD_STRING_VIEW"' default
+```
+
+If you have other flags in the `conf.tools.build` or `env.CXXFLAGS` sections, make sure to retain the existing flags and append the new ones. You can check them with:
+```
+conan profile show default
+```
+
+
+**Windows** developers may need to use the x64 native build tools.
+An easy way to do that is to run the shortcut "x64 Native Tools Command
+Prompt" for the version of Visual Studio that you have installed.
+
+   Windows developers must also build `rippled` and its dependencies for the x64
+   architecture:
+
+   ```
+   conan profile update settings.arch=x86_64 default
+   ```
+
+### Multiple compilers
+
+When `/usr/bin/g++` exists on a platform, it is the default cpp compiler. This
+default works for some users.
+
+However, if this compiler cannot build rippled or its dependencies, then you can
+install another compiler and set Conan and CMake to use it.
+Update the `conf.tools.build:compiler_executables` setting in order to set the correct variables (`CMAKE_<LANG>_COMPILER`) in the
+generated CMake toolchain file.
+For example, on Ubuntu 20, you may have gcc at `/usr/bin/gcc` and g++ at `/usr/bin/g++`; if that is the case, you can select those compilers with:
+```
+conan profile update '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.
+
+   ```
+   # Conan 1.x
+   conan export external/snappy snappy/1.1.10@
+   # Conan 2.x
+   conan export --version 1.1.10 external/snappy
+   ```
+
+Export our [Conan recipe for RocksDB](./external/rocksdb).
+It does not override paths to dependencies when building with Visual Studio.
+
+   ```
+   # Conan 1.x
+   conan export external/rocksdb rocksdb/9.7.3@
+   # Conan 2.x
+   conan export --version 9.7.3 external/rocksdb
+   ```
+
+Export our [Conan recipe for SOCI](./external/soci).
+It patches their CMake to correctly import its dependencies.
+
+   ```
+   # Conan 1.x
+   conan export external/soci soci/4.0.3@
+   # Conan 2.x
+   conan export --version 4.0.3 external/soci
+   ```
+
+Export our [Conan recipe for NuDB](./external/nudb).
+It fixes some source files to add missing `#include`s.
+
+
+   ```
+   # Conan 1.x
+   conan export external/nudb nudb/2.0.8@
+   # Conan 2.x
+   conan export --version 2.0.8 external/nudb
+   ```
+
+### Build and Test
+
+1. Create a build directory and move into it.
+
+   ```
+   mkdir .build
+   cd .build
+   ```
+
+   You can use any directory name. Conan treats your working directory as an
+   install folder and generates files with implementation details.
+   You don't need to worry about these files, but make sure to change
+   your working directory to your build directory before calling Conan.
+
+   **Note:** You can specify a directory for the installation files by adding
+   the `install-folder` or `-if` option to every `conan install` command
+   in the next step.
+
+2. Use conan to generate CMake files for every configuration you want to build:
+
+    ```
+    conan install .. --output-folder . --build missing --settings build_type=Release
+    conan install .. --output-folder . --build missing --settings build_type=Debug
+    ```
+
+    To build Debug, in the next step, be sure to set `-DCMAKE_BUILD_TYPE=Debug`
+
+    For a single-configuration generator, e.g. `Unix Makefiles` or `Ninja`,
+    you only need to run this command once.
+    For a multi-configuration generator, e.g. `Visual Studio`, you may want to
+    run it more than once.
+
+    Each of these commands should also have a different `build_type` setting.
+    A second command with the same `build_type` setting will overwrite the files
+    generated by the first. You can pass the build type on the command line with
+    `--settings build_type=$BUILD_TYPE` or in the profile itself,
+    under the section `[settings]` with the key `build_type`.
+
+    If you are using a Microsoft Visual C++ compiler,
+    then you will need to ensure consistency between the `build_type` setting
+    and the `compiler.runtime` setting.
+
+    When `build_type` is `Release`, `compiler.runtime` should be `MT`.
+
+    When `build_type` is `Debug`, `compiler.runtime` should be `MTd`.
+
+    ```
+    conan install .. --output-folder . --build missing --settings build_type=Release --settings compiler.runtime=MT
+    conan install .. --output-folder . --build missing --settings build_type=Debug --settings compiler.runtime=MTd
+    ```
+
+3. Configure CMake and pass the toolchain file generated by Conan, located at
+   `$OUTPUT_FOLDER/build/generators/conan_toolchain.cmake`.
+
+    Single-config generators:
+
+    Pass the CMake variable [`CMAKE_BUILD_TYPE`][build_type]
+    and make sure it matches the one of the `build_type` settings
+    you chose in the previous step.
+
+    For example, to build Debug, in the next command, replace "Release" with "Debug"
+
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release -Dxrpld=ON -Dtests=ON ..
+    ```
+
+
+    Multi-config generators:
+
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -Dxrpld=ON -Dtests=ON  ..
+    ```
+
+    **Note:** You can pass build options for `rippled` in this step.
+
+5. Build `rippled`.
+
+   For a single-configuration generator, it will build whatever configuration
+   you passed for `CMAKE_BUILD_TYPE`. For a multi-configuration generator,
+   you must pass the option `--config` to select the build configuration. 
+
+   Single-config generators:
+
+   ```
+   cmake --build .
+   ```
+
+   Multi-config generators:
+
+   ```
+   cmake --build . --config Release
+   cmake --build . --config Debug
+   ```
+
+6. Test rippled.
+
+   Single-config generators:
+
+   ```
+   ./rippled --unittest
+   ```
+
+   Multi-config generators:
+
+   ```
+   ./Release/rippled --unittest
+   ./Debug/rippled --unittest
+   ```
+
+   The location of `rippled` in your build directory depends on your CMake
+   generator. Pass `--help` to see the rest of the command line options.
+
+
+## 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 -Dxrpld=ON -Dtests=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.
+| `coverage` | OFF | Prepare the coverage report. |
+| `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
+| `tests` | OFF | Build tests. |
+| `unity` | ON | Configure a unity build. |
+| `xrpld` | OFF | Build the xrpld (`rippled`) application, and not just the libxrpl library. |
+
+[Unity builds][5] may be faster for the first build
+(at the cost of much more memory) since they concatenate sources into fewer
+translation units. Non-unity builds may be faster for incremental builds,
+and can be helpful for detecting `#include` omissions.
+
+
+## Troubleshooting
+
+
+### Conan
+
+After any updates or changes to dependencies, you may need to do the following:
+
+1. Remove your build directory.
+2. Remove the Conan cache:
+   ```
+   rm -rf ~/.conan/data
+   ```
+4. Re-run [conan install](#build-and-test).
+
+
+### 'protobuf/port_def.inc' file not found
+
+If `cmake --build .` results in an error due to a missing a protobuf file, then you might have generated CMake files for a different `build_type` than the `CMAKE_BUILD_TYPE` you passed to conan.
+
+```
+/rippled/.build/pb-xrpl.libpb/xrpl/proto/ripple.pb.h:10:10: fatal error: 'google/protobuf/port_def.inc' file not found
+   10 | #include <google/protobuf/port_def.inc>
+      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+1 error generated.
+```
+
+For example, if you want to build Debug:
+
+1. For conan install, pass `--settings build_type=Debug`
+2. For cmake, pass `-DCMAKE_BUILD_TYPE=Debug`
+
+
+### no std::result_of
+
+If your compiler version is recent enough to have removed `std::result_of` as
+part of C++20, e.g. Apple Clang 15.0, then you might need to add a preprocessor
+definition to your build.
+
+```
+conan profile update 'options.boost:extra_b2_flags="define=BOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'env.CFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
+conan profile update 'conf.tools.build:cflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
+conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
+```
+
+
+### call to 'async_teardown' is ambiguous
+
+If you are compiling with an early version of Clang 16, then you might hit
+a [regression][6] when compiling C++20 that manifests as an [error in a Boost
+header][7]. You can workaround it by adding this preprocessor definition:
+
+```
+conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
+conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
+```
+
+
+### recompile with -fPIC
+
+If you get a linker error suggesting that you recompile Boost with
+position-independent code, such as:
+
+```
+/usr/bin/ld.gold: error: /home/username/.conan/data/boost/1.77.0/_/_/package/.../lib/libboost_container.a(alloc_lib.o):
+  requires unsupported dynamic reloc 11; recompile with -fPIC
+```
+
+Conan most likely downloaded a bad binary distribution of the dependency.
+This seems to be a [bug][1] in Conan just for Boost 1.77.0 compiled with GCC
+for Linux. The solution is to build the dependency locally by passing
+`--build boost` when calling `conan install`.
+
+```
+conan install --build boost ...
+```
+
+
+## Add a Dependency
+
+If you want to experiment with a new package, follow these steps:
+
+1. Search for the package on [Conan Center](https://conan.io/center/).
+2. Modify [`conanfile.py`](./conanfile.py):
+    - Add a version of the package to the `requires` property.
+    - Change any default options for the package by adding them to the
+    `default_options` property (with syntax `'$package:$option': $value`).
+3. Modify [`CMakeLists.txt`](./CMakeLists.txt):
+    - Add a call to `find_package($package REQUIRED)`.
+    - Link a library from the package to the target `ripple_libs`
+    (search for the existing call to `target_link_libraries(ripple_libs INTERFACE ...)`).
+4. Start coding! Don't forget to include whatever headers you need from the package.
+
+
+[1]: https://github.com/conan-io/conan-center-index/issues/13168
+[2]: https://en.cppreference.com/w/cpp/compiler_support/20
+[3]: https://docs.conan.io/en/latest/getting_started.html
+[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
+[profile]: https://docs.conan.io/en/latest/reference/profiles.html

Builds/CMake/CMakeFuncs.cmake

@@ -1,869 +0,0 @@
-# This is a set of common functions and settings for rippled
-# and derived products.
-
-############################################################
-
-cmake_minimum_required(VERSION 3.1.0)
-
-if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
-  message(WARNING "Builds are strongly discouraged in "
-    "${CMAKE_SOURCE_DIR}.")
-endif()
-
-macro(parse_target)
-
-  if (NOT target OR target STREQUAL "default")
-    if (NOT CMAKE_BUILD_TYPE)
-      set(CMAKE_BUILD_TYPE Debug)
-    endif()
-    string(TOLOWER ${CMAKE_BUILD_TYPE} target)
-    if (APPLE)
-      set(target clang.${target})
-    elseif(WIN32)
-      set(target msvc)
-    else()
-      set(target gcc.${target})
-    endif()
-  endif()
-
-  if (target)
-    # Parse the target
-    set(remaining ${target})
-    while (remaining)
-      # get the component up to the next dot or end
-      string(REGEX REPLACE "^\\.?([^\\.]+).*$" "\\1" cur_component ${remaining})
-      string(REGEX REPLACE "^\\.?[^\\.]+(.*$)" "\\1" remaining ${remaining})
-
-      if (${cur_component} STREQUAL gcc)
-        if (DEFINED ENV{GNU_CC})
-          set(CMAKE_C_COMPILER $ENV{GNU_CC})
-        elseif ($ENV{CC} MATCHES .*gcc.*)
-          set(CMAKE_C_COMPILER $ENV{CC})
-        else()
-          find_program(CMAKE_C_COMPILER gcc)
-        endif()
-
-        if (DEFINED ENV{GNU_CXX})
-          set(CMAKE_CXX_COMPILER $ENV{GNU_CXX})
-        elseif ($ENV{CXX} MATCHES .*g\\+\\+.*)
-          set(CMAKE_CXX_COMPILER $ENV{CXX})
-        else()
-          find_program(CMAKE_CXX_COMPILER g++)
-        endif()
-      endif()
-
-      if (${cur_component} STREQUAL clang)
-        if (DEFINED ENV{CLANG_CC})
-          set(CMAKE_C_COMPILER $ENV{CLANG_CC})
-        elseif ($ENV{CC} MATCHES .*clang.*)
-          set(CMAKE_C_COMPILER $ENV{CC})
-        else()
-          find_program(CMAKE_C_COMPILER clang)
-        endif()
-
-        if (DEFINED ENV{CLANG_CXX})
-          set(CMAKE_CXX_COMPILER $ENV{CLANG_CXX})
-        elseif ($ENV{CXX} MATCHES .*clang.*)
-          set(CMAKE_CXX_COMPILER $ENV{CXX})
-        else()
-          find_program(CMAKE_CXX_COMPILER clang++)
-        endif()
-      endif()
-
-      if (${cur_component} STREQUAL msvc)
-        # TBD
-      endif()
-
-      if (${cur_component} STREQUAL unity)
-        set(unity true)
-        set(nonunity false)
-      endif()
-
-      if (${cur_component} STREQUAL nounity)
-        set(unity false)
-        set(nonunity true)
-      endif()
-
-      if (${cur_component} STREQUAL debug)
-        set(release false)
-      endif()
-
-      if (${cur_component} STREQUAL release)
-        set(release true)
-      endif()
-
-      if (${cur_component} STREQUAL coverage)
-        set(coverage true)
-        set(debug true)
-      endif()
-
-      if (${cur_component} STREQUAL profile)
-        set(profile true)
-      endif()
-
-      if (${cur_component} STREQUAL ci)
-        # Workarounds that make various CI builds work, but that
-        # we don't want in the general case.
-        set(ci true)
-        set(openssl_min 1.0.1)
-      endif()
-
-    endwhile()
-  endif()
-
-  if(CMAKE_C_COMPILER MATCHES "-NOTFOUND$" OR
-    CMAKE_CXX_COMPILER MATCHES "-NOTFOUND$")
-    message(FATAL_ERROR "Can not find appropriate compiler for target ${target}")
-  endif()
-
-  # If defined, promote the compiler path values to the CACHE, then
-  # unset the locals to prevent shadowing. Some scenarios do not
-  # need or want to find a compiler, such as -GNinja under Windows.
-  # Setting these values in those case may prevent CMake from finding
-  # a valid compiler.
-  if (CMAKE_C_COMPILER)
-    set(CMAKE_C_COMPILER ${CMAKE_C_COMPILER} CACHE FILEPATH
-      "Path to a program" FORCE)
-    unset(CMAKE_C_COMPILER)
-  endif (CMAKE_C_COMPILER)
-  if (CMAKE_CXX_COMPILER)
-    set(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER} CACHE FILEPATH
-      "Path to a program" FORCE)
-    unset(CMAKE_CXX_COMPILER)
-  endif (CMAKE_CXX_COMPILER)
-
-  if (release)
-    set(CMAKE_BUILD_TYPE Release)
-  else()
-    set(CMAKE_BUILD_TYPE Debug)
-  endif()
-
-  # ensure that the unity flags are set and exclusive
-  if (NOT DEFINED unity OR unity)
-    # Default to unity builds
-    set(unity true)
-    set(nonunity false)
-  else()
-    set(unity false)
-    set(nonunity true)
-  endif()
-
-  if (NOT unity)
-    set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}Classic)
-  endif()
-  # Promote this value to the CACHE, then unset the local
-  # to prevent shadowing.
-  set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE INTERNAL
-    "Choose the type of build, options are in CMAKE_CONFIGURATION_TYPES"
-    FORCE)
-  unset(CMAKE_BUILD_TYPE)
-
-endmacro()
-
-############################################################
-
-macro(setup_build_cache)
-  set(san "" CACHE STRING "On gcc & clang, add sanitizer
-    instrumentation")
-  set_property(CACHE san PROPERTY STRINGS ";address;thread")
-  set(assert false CACHE BOOL "Enables asserts, even in release builds")
-  set(static false CACHE BOOL
-    "On linux, link protobuf, openssl, libc++, and boost statically")
-  set(jemalloc false CACHE BOOL "Enables jemalloc for heap profiling")
-  set(perf false CACHE BOOL "Enables flags that assist with perf recording")
-
-  if (static AND (WIN32 OR APPLE))
-    message(FATAL_ERROR "Static linking is only supported on linux.")
-  endif()
-
-  if (perf AND (WIN32 OR APPLE))
-    message(FATAL_ERROR "perf flags are only supported on linux.")
-  endif()
-
-  if (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles" AND NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Debug)
-  endif()
-
-  # Can't exclude files from configurations, so can't support both
-  # unity and nonunity configurations at the same time
-  if (NOT DEFINED unity OR unity)
-    set(CMAKE_CONFIGURATION_TYPES
-      Debug
-      Release)
-  else()
-    set(CMAKE_CONFIGURATION_TYPES
-      DebugClassic
-      ReleaseClassic)
-  endif()
-
-  # Promote this value to the CACHE, then unset the local
-  # to prevent shadowing.
-  set(CMAKE_CONFIGURATION_TYPES
-    ${CMAKE_CONFIGURATION_TYPES} CACHE STRING "" FORCE)
-  unset(CMAKE_CONFIGURATION_TYPES)
-endmacro()
-
-############################################################
-
-function(prepend var prefix)
-  set(listVar "")
-  foreach(f ${ARGN})
-    list(APPEND listVar "${prefix}${f}")
-  endforeach(f)
-  set(${var} "${listVar}" PARENT_SCOPE)
-endfunction()
-
-macro(append_flags name)
-  foreach (arg ${ARGN})
-    set(${name} "${${name}} ${arg}")
-  endforeach()
-endmacro()
-
-macro(group_sources_in source_dir curdir)
-  file(GLOB children RELATIVE ${source_dir}/${curdir}
-    ${source_dir}/${curdir}/*)
-  foreach (child ${children})
-    if (IS_DIRECTORY ${source_dir}/${curdir}/${child})
-      group_sources_in(${source_dir} ${curdir}/${child})
-    else()
-      string(REPLACE "/" "\\" groupname ${curdir})
-      source_group(${groupname} FILES
-        ${source_dir}/${curdir}/${child})
-    endif()
-  endforeach()
-endmacro()
-
-macro(group_sources curdir)
-  group_sources_in(${PROJECT_SOURCE_DIR} ${curdir})
-endmacro()
-
-macro(add_with_props src_var files)
-  list(APPEND ${src_var} ${files})
-  foreach (arg ${ARGN})
-    set(props "${props} ${arg}")
-  endforeach()
-  set_source_files_properties(
-    ${files}
-    PROPERTIES COMPILE_FLAGS
-    ${props})
-endmacro()
-
-############################################################
-
-macro(determine_build_type)
-  if ("${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang") # both Clang and AppleClang
-    set(is_clang true)
-  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    set(is_gcc true)
-  elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-    set(is_msvc true)
-  endif()
-
-  if (${CMAKE_GENERATOR} STREQUAL "Xcode")
-    set(is_xcode true)
-  else()
-    set(is_xcode false)
-  endif()
-
-  if (NOT is_gcc AND NOT is_clang AND NOT is_msvc)
-    message("Current compiler is ${CMAKE_CXX_COMPILER_ID}")
-    message(FATAL_ERROR "Missing compiler. Must be GNU, Clang, or MSVC")
-  endif()
-endmacro()
-
-############################################################
-
-macro(check_gcc4_abi)
-  # Check if should use gcc4's ABI
-  set(gcc4_abi false)
-
-  if ($ENV{RIPPLED_OLD_GCC_ABI})
-    set(gcc4_abi true)
-  endif()
-
-  if (is_gcc AND NOT gcc4_abi)
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 5)
-      execute_process(COMMAND lsb_release -si OUTPUT_VARIABLE lsb)
-      string(STRIP "${lsb}" lsb)
-      if ("${lsb}" STREQUAL "Ubuntu")
-        execute_process(COMMAND lsb_release -sr OUTPUT_VARIABLE lsb)
-        string(STRIP ${lsb} lsb)
-        if (${lsb} VERSION_LESS 15.1)
-          set(gcc4_abi true)
-        endif()
-      endif()
-    endif()
-  endif()
-
-  if (gcc4_abi)
-    add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0)
-  endif()
-endmacro()
-
-############################################################
-
-macro(special_build_flags)
-  if (coverage)
-    add_compile_options(-fprofile-arcs -ftest-coverage)
-    append_flags(CMAKE_EXE_LINKER_FLAGS -fprofile-arcs -ftest-coverage)
-  endif()
-
-  if (profile)
-    add_compile_options(-p -pg)
-    append_flags(CMAKE_EXE_LINKER_FLAGS -p -pg)
-  endif()
-endmacro()
-
-############################################################
-
-# Params: Boost components to search for.
-macro(use_boost)
-    if ((NOT DEFINED BOOST_ROOT) AND (DEFINED ENV{BOOST_ROOT}))
-        set(BOOST_ROOT $ENV{BOOST_ROOT})
-    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(DEFINED BOOST_ROOT)
-            if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND IS_DIRECTORY ${BOOST_ROOT}/stage64/lib)
-                set(Boost_LIBRARY_DIR ${BOOST_ROOT}/stage64/lib)
-            else()
-                set(Boost_LIBRARY_DIR ${BOOST_ROOT}/stage/lib)
-            endif()
-        endif()
-    endif()
-
-    if (is_clang AND DEFINED ENV{CLANG_BOOST_ROOT})
-      set(BOOST_ROOT $ENV{CLANG_BOOST_ROOT})
-    endif()
-
-    # 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 OR APPLE)
-      set(Boost_USE_STATIC_LIBS on)
-    endif()
-    set(Boost_USE_MULTITHREADED on)
-    set(Boost_USE_STATIC_RUNTIME off)
-    if(MSVC)
-        find_package(Boost REQUIRED)
-    else()
-        find_package(Boost REQUIRED ${ARGN})
-    endif()
-
-    if (Boost_FOUND OR
-        ((CYGWIN OR WIN32) AND Boost_INCLUDE_DIRS AND Boost_LIBRARY_DIRS))
-      if(NOT Boost_FOUND)
-        message(WARNING "Boost directory found, but not all components. May not be able to build.")
-      endif()
-
-      if(MSVC14)
-        # VS2017 with boost <= 1.66.0 requires a flag to suppress warnings
-        if(NOT Boost_VERSION VERSION_GREATER 106600)
-          add_definitions(-DBOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE)
-        endif()
-      endif()
-
-      if (is_xcode)
-          include_directories(BEFORE ${Boost_INCLUDE_DIRS})
-          append_flags(CMAKE_CXX_FLAGS --system-header-prefix="boost/")
-      else()
-          include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
-      endif()
-
-      if(MSVC)
-          link_directories(${Boost_LIBRARY_DIRS})
-      endif()
-    else()
-      message(FATAL_ERROR "Boost not found")
-    endif()
-endmacro()
-
-macro(use_pthread)
-  if (NOT WIN32)
-    set(THREADS_PREFER_PTHREAD_FLAG ON)
-    find_package(Threads)
-    add_compile_options(${CMAKE_THREAD_LIBS_INIT})
-  endif()
-endmacro()
-
-macro(use_openssl openssl_min)
-  if (APPLE AND NOT DEFINED ENV{OPENSSL_ROOT_DIR})
-    find_program(HOMEBREW brew)
-    if (NOT HOMEBREW STREQUAL "HOMEBREW-NOTFOUND")
-      execute_process(COMMAND brew --prefix openssl
-        OUTPUT_VARIABLE OPENSSL_ROOT_DIR
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-    endif()
-  endif()
-
-  if (WIN32)
-    if ((NOT DEFINED OPENSSL_ROOT) AND (DEFINED ENV{OPENSSL_ROOT}))
-      set(OPENSSL_ROOT $ENV{OPENSSL_ROOT})
-    endif()
-    file(TO_CMAKE_PATH "${OPENSSL_ROOT}" OPENSSL_ROOT)
-    if (DEFINED OPENSSL_ROOT)
-      include_directories(${OPENSSL_ROOT}/include)
-      link_directories(${OPENSSL_ROOT}/lib)
-    endif()
-  else()
-    if (static)
-      set(tmp CMAKE_FIND_LIBRARY_SUFFIXES)
-      set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
-    endif()
-
-    find_package(OpenSSL)
-    # 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
-    find_package(ZLIB)
-
-    if (static)
-      set(CMAKE_FIND_LIBRARY_SUFFIXES tmp)
-    endif()
-
-    if (OPENSSL_FOUND)
-      include_directories(${OPENSSL_INCLUDE_DIR})
-      list(APPEND OPENSSL_LIBRARIES ${ZLIB_LIBRARIES})
-    else()
-      message(FATAL_ERROR "OpenSSL not found")
-    endif()
-    if (UNIX AND NOT APPLE AND ${OPENSSL_VERSION} VERSION_LESS ${openssl_min})
-      message(FATAL_ERROR
-        "Your openssl is Version: ${OPENSSL_VERSION}, ${openssl_min} or better is required.")
-    endif()
-  endif()
-endmacro()
-
-macro(use_protobuf)
-  if (WIN32)
-    if (DEFINED ENV{PROTOBUF_ROOT})
-      include_directories($ENV{PROTOBUF_ROOT}/src)
-      link_directories($ENV{PROTOBUF_ROOT}/src/.libs)
-    endif()
-
-    # Modified from FindProtobuf.cmake
-    FUNCTION(PROTOBUF_GENERATE_CPP SRCS HDRS PROTOFILES)
-      # argument parsing
-      IF(NOT PROTOFILES)
-        MESSAGE(SEND_ERROR "Error: PROTOBUF_GENERATE_CPP() called without any proto files")
-        RETURN()
-      ENDIF()
-
-      SET(OUTPATH ${CMAKE_CURRENT_BINARY_DIR})
-      SET(PROTOROOT ${CMAKE_CURRENT_SOURCE_DIR})
-      # the real logic
-      SET(${SRCS})
-      SET(${HDRS})
-      FOREACH(PROTOFILE ${PROTOFILES})
-        # ensure that the file ends with .proto
-        STRING(REGEX MATCH "\\.proto$$" PROTOEND ${PROTOFILE})
-        IF(NOT PROTOEND)
-          MESSAGE(SEND_ERROR "Proto file '${PROTOFILE}' does not end with .proto")
-        ENDIF()
-
-        GET_FILENAME_COMPONENT(PROTO_PATH ${PROTOFILE} PATH)
-        GET_FILENAME_COMPONENT(ABS_FILE ${PROTOFILE} ABSOLUTE)
-        GET_FILENAME_COMPONENT(FILE_WE ${PROTOFILE} NAME_WE)
-
-        STRING(REGEX MATCH "^${PROTOROOT}" IN_ROOT_PATH ${PROTOFILE})
-        STRING(REGEX MATCH "^${PROTOROOT}" IN_ROOT_ABS_FILE ${ABS_FILE})
-
-        IF(IN_ROOT_PATH)
-          SET(MATCH_PATH ${PROTOFILE})
-        ELSEIF(IN_ROOT_ABS_FILE)
-          SET(MATCH_PATH ${ABS_FILE})
-        ELSE()
-          MESSAGE(SEND_ERROR "Proto file '${PROTOFILE}' is not in protoroot '${PROTOROOT}'")
-        ENDIF()
-
-        # build the result file name
-        STRING(REGEX REPLACE "^${PROTOROOT}(/?)" "" ROOT_CLEANED_FILE ${MATCH_PATH})
-        STRING(REGEX REPLACE "\\.proto$$" "" EXT_CLEANED_FILE ${ROOT_CLEANED_FILE})
-
-        SET(CPP_FILE "${OUTPATH}/${EXT_CLEANED_FILE}.pb.cc")
-        SET(H_FILE "${OUTPATH}/${EXT_CLEANED_FILE}.pb.h")
-
-        LIST(APPEND ${SRCS} "${CPP_FILE}")
-        LIST(APPEND ${HDRS} "${H_FILE}")
-
-        ADD_CUSTOM_COMMAND(
-          OUTPUT "${CPP_FILE}" "${H_FILE}"
-          COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPATH}
-          COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
-          ARGS "--cpp_out=${OUTPATH}" --proto_path "${PROTOROOT}" "${MATCH_PATH}"
-          DEPENDS ${ABS_FILE}
-          COMMENT "Running C++ protocol buffer compiler on ${MATCH_PATH} with root ${PROTOROOT}, generating: ${CPP_FILE}"
-          VERBATIM)
-
-      ENDFOREACH()
-
-      SET_SOURCE_FILES_PROPERTIES(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
-      SET(${SRCS} ${${SRCS}} PARENT_SCOPE)
-      SET(${HDRS} ${${HDRS}} PARENT_SCOPE)
-
-    ENDFUNCTION()
-
-    set(PROTOBUF_PROTOC_EXECUTABLE Protoc) # must be on path
-  else()
-    if (static)
-      set(tmp CMAKE_FIND_LIBRARY_SUFFIXES)
-      set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
-    endif()
-
-    find_package(Protobuf REQUIRED)
-
-    if (static)
-      set(CMAKE_FIND_LIBRARY_SUFFIXES tmp)
-    endif()
-
-    if (is_clang AND DEFINED ENV{CLANG_PROTOBUF_ROOT})
-      link_directories($ENV{CLANG_PROTOBUF_ROOT}/src/.libs)
-      include_directories($ENV{CLANG_PROTOBUF_ROOT}/src)
-    else()
-      include_directories(${PROTOBUF_INCLUDE_DIRS})
-    endif()
-
-    if (is_xcode)
-      append_flags(CMAKE_CXX_FLAGS --system-header-prefix="google/protobuf")
-    endif()
-
-  endif()
-  include_directories(${CMAKE_CURRENT_BINARY_DIR})
-
-  file(GLOB ripple_proto src/ripple/proto/*.proto)
-  PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS ${ripple_proto})
-
-  if (WIN32)
-    include_directories(src/protobuf/src
-      src/protobuf/vsprojects
-      ${CMAKE_CURRENT_BINARY_DIR}/src/ripple/proto)
-  endif()
-
-endmacro()
-
-############################################################
-
-macro(setup_build_boilerplate)
-  if (NOT WIN32 AND san)
-    add_compile_options(-fsanitize=${san} -fno-omit-frame-pointer)
-
-    append_flags(CMAKE_EXE_LINKER_FLAGS
-      -fsanitize=${san})
-
-    string(TOLOWER ${san} ci_san)
-    if (${ci_san} STREQUAL address)
-      if (is_gcc)
-        set(SANITIZER_LIBRARIES asan)
-      endif()
-      add_definitions(-DSANITIZER=ASAN)
-    endif()
-    if (${ci_san} STREQUAL thread)
-      if (is_gcc)
-        set(SANITIZER_LIBRARIES tsan)
-      endif()
-      add_definitions(-DSANITIZER=TSAN)
-    endif()
-  endif()
-
-  if (perf)
-    add_compile_options(-fno-omit-frame-pointer)
-  endif()
-
-  ############################################################
-
-  add_definitions(
-    -DOPENSSL_NO_SSL2
-    -DDEPRECATED_IN_MAC_OS_X_VERSION_10_7_AND_LATER
-    -DHAVE_USLEEP=1
-    -DSOCI_CXX_C11=1
-    -D_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
-    -DBOOST_NO_AUTO_PTR
-    )
-
-  if (is_gcc)
-    add_compile_options(-Wno-unused-but-set-variable -Wno-deprecated)
-
-    # use gold linker if available
-    execute_process(
-      COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
-      ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
-    # NOTE: THE gold linker inserts -rpath as DT_RUNPATH by default
-    #  intead of DT_RPATH, so you might have slightly unexpected
-    #  runtime ld behavior if you were expecting DT_RPATH.
-    #  Specify --disable-new-dtags to gold if you do not want
-    #  the default DT_RUNPATH behavior. This rpath treatment as well
-    #  as static/dynamic selection means that gold does not currently
-    #  have ideal default behavior when we are using jemalloc. Thus
-    #  for simplicity we don't use it when jemalloc is requested.
-    #  An alternative to disabling would be to figure out all the settings
-    #  required to make gold play nicely with jemalloc.
-    if (("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
-        append_flags(CMAKE_EXE_LINKER_FLAGS -fuse-ld=gold -Wl,--no-as-needed)
-    endif ()
-    unset(LD_VERSION)
-  endif()
-
-  # Generator expressions are not supported in add_definitions, use set_property instead
-  set_property(
-    DIRECTORY
-    APPEND
-    PROPERTY COMPILE_DEFINITIONS
-    $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:DEBUG _DEBUG>)
-
-  if (NOT assert)
-    set_property(
-      DIRECTORY
-      APPEND
-      PROPERTY COMPILE_DEFINITIONS
-      $<$<OR:$<BOOL:${profile}>,$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:NDEBUG>)
-  else()
-    # CMAKE_CXX_FLAGS_RELEASE is created by CMake for most / all generators
-    #  with defaults including /DNDEBUG or -DNDEBUG, and that value is stored
-    #  in the cache. Override that locally so that the cache value will be
-    #  avaiable if "assert" is ever changed.
-    STRING(REGEX REPLACE "[-/]DNDEBUG" "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
-    STRING(REGEX REPLACE "[-/]DNDEBUG" "" CMAKE_CXX_FLAGS_RELEASECLASSIC "${CMAKE_CXX_FLAGS_RELEASECLASSIC}")
-    STRING(REGEX REPLACE "[-/]DNDEBUG" "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
-    STRING(REGEX REPLACE "[-/]DNDEBUG" "" CMAKE_C_FLAGS_RELEASECLASSIC "${CMAKE_C_FLAGS_RELEASECLASSIC}")
-  endif()
-
-  if (jemalloc)
-    find_package(jemalloc REQUIRED)
-    add_definitions(-DPROFILE_JEMALLOC)
-    include_directories(SYSTEM ${JEMALLOC_INCLUDE_DIRS})
-    link_libraries(${JEMALLOC_LIBRARIES})
-    get_filename_component(JEMALLOC_LIB_PATH ${JEMALLOC_LIBRARIES} DIRECTORY)
-    set(CMAKE_BUILD_RPATH ${CMAKE_BUILD_RPATH} ${JEMALLOC_LIB_PATH})
-  endif()
-
-  if (NOT WIN32)
-    add_definitions(-D_FILE_OFFSET_BITS=64)
-    append_flags(CMAKE_CXX_FLAGS -frtti -std=c++14 -Wno-invalid-offsetof -Wdeprecated
-      -DBOOST_COROUTINE_NO_DEPRECATION_WARNING -DBOOST_COROUTINES_NO_DEPRECATION_WARNING)
-    add_compile_options(-Wall -Wno-sign-compare -Wno-char-subscripts -Wno-format
-      -Wno-unused-local-typedefs -g)
-    # There seems to be an issue using generator experssions with multiple values,
-    # split the expression
-    add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:-O3>)
-    add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:-fno-strict-aliasing>)
-    append_flags(CMAKE_EXE_LINKER_FLAGS -rdynamic -g)
-
-    if (is_clang)
-      add_compile_options(
-        -Wno-redeclared-class-member -Wno-mismatched-tags -Wno-deprecated-register)
-      add_definitions(-DBOOST_ASIO_HAS_STD_ARRAY)
-
-      # use ldd linker if available
-      execute_process(
-        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
-        ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
-      if ("${LD_VERSION}" MATCHES "LLD")
-        append_flags(CMAKE_EXE_LINKER_FLAGS -fuse-ld=lld)
-      endif ()
-      unset(LD_VERSION)
-    endif()
-
-    if (APPLE)
-      add_compile_options(
-        -Wno-deprecated-declarations -Wno-unused-function)
-    endif()
-
-    if (is_gcc)
-      add_compile_options(-Wno-unused-but-set-variable -Wno-unused-local-typedefs)
-      add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:-O0>)
-    endif (is_gcc)
-  else(NOT WIN32)
-    add_compile_options(
-      /bigobj            # Increase object file max size
-      /EHa               # ExceptionHandling all
-      /fp:precise        # Floating point behavior
-      /Gd                # __cdecl calling convention
-      /Gm-               # Minimal rebuild: disabled
-      /GR                # Enable RTTI
-      /Gy-               # Function level linking: disabled
-      /FS
-      /MP                # Multiprocessor compilation
-      /openmp-           # pragma omp: disabled
-      /Zc:forScope       # Language conformance: for scope
-      /Zi                # Generate complete debug info
-      /errorReport:none  # No error reporting to Internet
-      /nologo            # Suppress login banner
-      /W3                # Warning level 3
-      /WX-               # Disable warnings as errors
-      /wd4018            # Disable signed/unsigned comparison warnings
-      /wd4244            # Disable float to int possible loss of data warnings
-      /wd4267            # Disable size_t to T possible loss of data warnings
-      /wd4800            # Disable C4800(int to bool performance)
-      /wd4503            # Decorated name length exceeded, name was truncated
-      )
-    add_definitions(
-      -D_WIN32_WINNT=0x6000
-      -D_SCL_SECURE_NO_WARNINGS
-      -D_CRT_SECURE_NO_WARNINGS
-      -DWIN32_CONSOLE
-      -DNOMINMAX
-      -DBOOST_COROUTINE_NO_DEPRECATION_WARNING
-      -DBOOST_COROUTINES_NO_DEPRECATION_WARNING)
-    append_flags(CMAKE_EXE_LINKER_FLAGS
-      /DEBUG
-      /DYNAMICBASE
-      /ERRORREPORT:NONE
-      /MACHINE:X64
-      /MANIFEST
-      /nologo
-      /NXCOMPAT
-      /SUBSYSTEM:CONSOLE
-      /TLBID:1)
-
-
-    # There seems to be an issue using generator experssions with multiple values,
-    # split the expression
-    # /GS  Buffers security check: enable
-    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:/GS>)
-    # /MTd Language: Multi-threaded Debug CRT
-    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:/MTd>)
-    # /Od  Optimization: Disabled
-    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:/Od>)
-    # /RTC1 Run-time error checks:
-    add_compile_options($<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:/RTC1>)
-
-    # Generator expressions are not supported in add_definitions, use set_property instead
-    set_property(
-      DIRECTORY
-      APPEND
-      PROPERTY COMPILE_DEFINITIONS
-      $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:_CRTDBG_MAP_ALLOC>)
-
-    # /MT Language: Multi-threaded CRT
-    add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:/MT>)
-    add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:/Ox>)
-    # /Ox Optimization: Full
-
-  endif (NOT WIN32)
-
-  if (static)
-    append_flags(CMAKE_EXE_LINKER_FLAGS -static-libstdc++)
-    # set_target_properties(ripple-libpp PROPERTIES LINK_SEARCH_START_STATIC 1)
-    # set_target_properties(ripple-libpp PROPERTIES LINK_SEARCH_END_STATIC 1)
-  endif()
-
-  ## The following options were migrated from the erstwhile BeastConfig.h
-  ## Some of these should be considered for removal in the future if
-  ## unused or unmaintained
-
-  # beast_no_unit_test_inline
-  #    Prevents unit test definitions from being inserted into a global table
-  if (beast_no_unit_test_inline)
-    add_definitions(-DBEAST_NO_UNIT_TEST_INLINE=1)
-  endif()
-
-  # beast_force_debug
-  #    Force BEAST_DEBUG behavior regardless of other compiler settings
-  if (beast_force_debug)
-    add_definitions(-DBEAST_FORCE_DEBUG=1)
-  endif()
-
-  # beast_check_mem_leaks
-  #    Force BEAST_CHECK_MEMORY_LEAKS to be ON.  Default is ON only for debug
-  #    builds. Only implemeted for windows builds.
-  if (beast_check_mem_leaks)
-    add_definitions(-DBEAST_CHECK_MEMORY_LEAKS=1)
-  elseif(DEFINED beast_check_mem_leaks)
-    add_definitions(-DBEAST_CHECK_MEMORY_LEAKS=0)
-  endif()
-
-  if (WIN32)
-    # beast_disable_auto_link
-    #    Disables autolinking of system library dependencies on windows
-    if (beast_disable_auto_link)
-      add_definitions(-DBEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1)
-    endif()
-  endif()
-
-  # dump_leaks_on_exit
-  #    Displays heap blocks and counted objects which were not disposed of
-  #    during exit. Only implemented for windows builds.
-  if (DEFINED dump_leaks_on_exit AND NOT dump_leaks_on_exit)
-    add_definitions(-DRIPPLE_DUMP_LEAKS_ON_EXIT=0)
-  else ()
-    add_definitions(-DRIPPLE_DUMP_LEAKS_ON_EXIT=1)
-  endif()
-
-  # NOTE - THIS OPTION CURRENTLY DOES NOT COMPILE !!
-  # verify_nodeobject_keys
-  #    This verifies that the hash of node objects matches the payload.
-  #    This check is expensive - use with caution.
-  if (verify_nodeobject_keys)
-    add_definitions(-DRIPPLE_VERIFY_NODEOBJECT_KEYS=1)
-  endif()
-
-  # single_io_service_thread
-  #    Restricts the number of threads calling io_service::run to one.
-  #    This can be useful when debugging."
-  if (single_io_service_thread)
-    add_definitions(-DRIPPLE_SINGLE_IO_SERVICE_THREAD=1)
-  endif()
-
-  # use_rocksdb
-  #    Controls whether or not the RocksDB database back-end is compiled into
-  #    rippled. RocksDB requires a relatively modern C++ compiler (tested with
-  #    gcc versions 4.8.1 and later) that supports some C++11 features. The
-  #    default is ON for modern unix compilers and OFF for everything else.
-  if (use_rocksdb)
-    add_definitions(-DRIPPLE_ROCKSDB_AVAILABLE=1)
-  elseif(DEFINED use_rocksdb)
-    add_definitions(-DRIPPLE_ROCKSDB_AVAILABLE=0)
-  endif()
-
-endmacro()
-
-############################################################
-
-macro(create_build_folder cur_project)
-  if (NOT WIN32)
-    ADD_CUSTOM_TARGET(build_folder ALL
-      COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}
-      COMMENT "Creating build output folder")
-    add_dependencies(${cur_project} build_folder)
-  endif()
-endmacro()
-
-macro(set_startup_project cur_project)
-  if (WIN32 AND NOT ci)
-    if (CMAKE_VERSION VERSION_LESS 3.6)
-      message(WARNING
-        "Setting the VS startup project requires cmake 3.6 or later. Please upgrade.")
-    endif()
-    set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY
-      VS_STARTUP_PROJECT ${cur_project})
-  endif()
-endmacro()
-
-macro(link_common_libraries cur_project)
-  if (NOT MSVC)
-    target_link_libraries(${cur_project} ${Boost_LIBRARIES})
-    target_link_libraries(${cur_project} dl)
-    target_link_libraries(${cur_project} Threads::Threads)
-    if (APPLE)
-      find_library(app_kit AppKit)
-      find_library(foundation Foundation)
-      target_link_libraries(${cur_project}
-        ${app_kit} ${foundation})
-    else()
-      target_link_libraries(${cur_project} rt)
-    endif()
-  else(NOT MSVC)
-    target_link_libraries(${cur_project}
-      $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:VC/static/ssleay32MTd>
-      $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugClassic>>:VC/static/libeay32MTd>)
-    target_link_libraries(${cur_project}
-      $<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:VC/static/ssleay32MT>
-      $<$<OR:$<CONFIG:Release>,$<CONFIG:ReleaseClassic>>:VC/static/libeay32MT>)
-    target_link_libraries(${cur_project}
-      legacy_stdio_definitions.lib Shlwapi kernel32 user32 gdi32 winspool comdlg32
-      advapi32 shell32 ole32 oleaut32 uuid odbc32 odbccp32 crypt32)
-  endif (NOT MSVC)
-endmacro()

Builds/CMake/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/Test.py

@@ -1,369 +0,0 @@
-#!/usr/bin/env python
-
-#    This file is part of rippled: https://github.com/ripple/rippled
-#    Copyright (c) 2012 - 2017 Ripple Labs Inc.
-#
-#    Permission to use, copy, modify, and/or distribute this software for any
-#    purpose  with  or without fee is hereby granted, provided that the above
-#    copyright notice and this permission notice appear in all copies.
-#
-#    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-#    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-#    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-#    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-#    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-#    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-#    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-"""
-Invocation:
-
-    ./Builds/Test.py - builds and tests all configurations
-
-The build must succeed without shell aliases for this to work.
-
-To pass flags to cmake, put them at the very end of the command line, after
-the -- flag - like this:
-
-    ./Builds/Test.py -- -j4  # Pass -j4 to cmake --build
-
-
-Common problems:
-
-1) Boost not found. Solution: export BOOST_ROOT=[path to boost folder]
-
-2) OpenSSL not found. Solution: export OPENSSL_ROOT=[path to OpenSSL folder]
-
-3) cmake is not found. Solution: Be sure cmake directory is on your $PATH
-
-"""
-from __future__ import absolute_import, division, print_function, unicode_literals
-
-import argparse
-import itertools
-import os
-import platform
-import re
-import shutil
-import sys
-import subprocess
-
-
-def powerset(iterable):
-    """powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"""
-    s = list(iterable)
-    return itertools.chain.from_iterable(itertools.combinations(s, r) for r in range(len(s) + 1))
-
-IS_WINDOWS = platform.system().lower() == 'windows'
-IS_OS_X = platform.system().lower() == 'darwin'
-
-# CMake
-if IS_WINDOWS:
-    CMAKE_UNITY_CONFIGS = ['Debug', 'Release']
-    CMAKE_NONUNITY_CONFIGS = ['DebugClassic', 'ReleaseClassic']
-else:
-    CMAKE_UNITY_CONFIGS = []
-    CMAKE_NONUNITY_CONFIGS = []
-CMAKE_UNITY_COMBOS = { '' : [['rippled', 'rippled_classic'], CMAKE_UNITY_CONFIGS],
-    '.nounity' : [['rippled', 'rippled_unity'], CMAKE_NONUNITY_CONFIGS] }
-
-if IS_WINDOWS:
-    CMAKE_DIR_TARGETS = { ('msvc' + unity,) : targets for unity, targets in
-        CMAKE_UNITY_COMBOS.items() }
-elif IS_OS_X:
-    CMAKE_DIR_TARGETS = { (build + unity,) : targets
-                   for build in ['debug', 'release']
-                   for unity, targets in CMAKE_UNITY_COMBOS.items() }
-else:
-    CMAKE_DIR_TARGETS = { (cc + "." + build + unity,) : targets
-                   for cc in ['gcc', 'clang']
-                   for build in ['debug', 'release', 'coverage', 'profile']
-                   for unity, targets in CMAKE_UNITY_COMBOS.items() }
-
-# list of tuples of all possible options
-if IS_WINDOWS or IS_OS_X:
-    CMAKE_ALL_GENERATE_OPTIONS = [tuple(x) for x in powerset(['-GNinja', '-Dassert=true'])]
-else:
-    CMAKE_ALL_GENERATE_OPTIONS = list(set(
-        [tuple(x) for x in powerset(['-GNinja', '-Dstatic=true', '-Dassert=true', '-Dsan=address'])] +
-        [tuple(x) for x in powerset(['-GNinja', '-Dstatic=true', '-Dassert=true', '-Dsan=thread'])]))
-
-parser = argparse.ArgumentParser(
-    description='Test.py - run ripple tests'
-)
-
-parser.add_argument(
-    '--all', '-a',
-    action='store_true',
-    help='Build all configurations.',
-)
-
-parser.add_argument(
-    '--keep_going', '-k',
-    action='store_true',
-    help='Keep going after one configuration has failed.',
-)
-
-parser.add_argument(
-    '--silent', '-s',
-    action='store_true',
-    help='Silence all messages except errors',
-)
-
-parser.add_argument(
-    '--verbose', '-v',
-    action='store_true',
-    help=('Report more information about which commands are executed and the '
-          'results.'),
-)
-
-parser.add_argument(
-    '--test', '-t',
-    default='',
-    help='Add a prefix for unit tests',
-)
-
-parser.add_argument(
-    '--testjobs',
-    default='0',
-    type=int,
-    help='Run tests in parallel'
-)
-
-parser.add_argument(
-    '--clean', '-c',
-    action='store_true',
-    help='delete all build artifacts after testing',
-)
-
-parser.add_argument(
-    '--quiet', '-q',
-    action='store_true',
-    help='Reduce output where possible (unit tests)',
-)
-
-parser.add_argument(
-    '--dir', '-d',
-    default=(),
-    nargs='*',
-    help='Specify one or more CMake dir names. '
-        'Will also be used as -Dtarget=<dir> running cmake.'
-)
-
-parser.add_argument(
-    '--target',
-    default=(),
-    nargs='*',
-    help='Specify one or more CMake build targets. '
-        'Will be used as --target <target> running cmake --build.'
-    )
-
-parser.add_argument(
-    '--config',
-    default=(),
-    nargs='*',
-    help='Specify one or more CMake build configs. '
-        'Will be used as --config <config> running cmake --build.'
-    )
-
-parser.add_argument(
-    '--generator_option',
-    action='append',
-    help='Specify a CMake generator option. Repeat for multiple options. '
-        'Will be passed to the cmake generator. '
-        'Due to limits of the argument parser, arguments starting with \'-\' '
-        'must be attached to this option. e.g. --generator_option=-GNinja.')
-
-parser.add_argument(
-    '--build_option',
-    action='append',
-    help='Specify a build option. Repeat for multiple options. '
-        'Will be passed to the build tool via cmake --build. '
-        'Due to limits of the argument parser, arguments starting with \'-\' '
-        'must be attached to this option. e.g. --build_option=-j8.')
-
-parser.add_argument(
-    'extra_args',
-    default=(),
-    nargs='*',
-    help='Extra arguments are passed through to the tools'
-)
-
-ARGS = parser.parse_args()
-
-def decodeString(line):
-    # Python 2 vs. Python 3
-    if isinstance(line, str):
-        return line
-    else:
-        return line.decode()
-
-def shell(cmd, args=(), silent=False):
-    """"Execute a shell command and return the output."""
-    silent = ARGS.silent or silent
-    verbose = not silent and ARGS.verbose
-    if verbose:
-        print('$' + cmd, *args)
-
-    command = (cmd,) + args
-
-    # shell is needed in Windows to find executable in the path
-    process = subprocess.Popen(
-        command,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        shell=IS_WINDOWS)
-    lines = []
-    count = 0
-    # readline returns '' at EOF
-    for line in iter(process.stdout.readline, ''):
-        if process.poll() is None:
-            decoded = decodeString(line)
-            lines.append(decoded)
-            if verbose:
-                print(decoded, end='')
-            elif not silent:
-                count += 1
-                if count >= 80:
-                    print()
-                    count = 0
-                else:
-                    print('.', end='')
-        else:
-            break
-
-    if not verbose and count:
-        print()
-    process.wait()
-    return process.returncode, lines
-
-def get_cmake_dir(cmake_dir):
-    return os.path.join('build' , 'cmake' , cmake_dir)
-
-def run_cmake(directory, cmake_dir, args):
-    print('Generating build in', directory, 'with', *args or ('default options',))
-    old_dir = os.getcwd()
-    if not os.path.exists(directory):
-        os.makedirs(directory)
-    os.chdir(directory)
-    if IS_WINDOWS and not any(arg.startswith("-G") for arg in args) and not os.path.exists("CMakeCache.txt"):
-        if '--ninja' in args:
-            args += ( '-GNinja', )
-        else:
-            args += ( '-GVisual Studio 14 2015 Win64', )
-    args += ( '-Dtarget=' + cmake_dir, os.path.join('..', '..', '..'), )
-    resultcode, lines = shell('cmake', args)
-
-    if resultcode:
-        print('Generating FAILED:')
-        if not ARGS.verbose:
-            print(*lines, sep='')
-        sys.exit(1)
-
-    os.chdir(old_dir)
-
-def run_cmake_build(directory, target, config, args):
-    print('Building', target, config, 'in', directory, 'with', *args or ('default options',))
-    build_args=('--build', directory)
-    if target:
-      build_args += ('--target', target)
-    if config:
-      build_args += ('--config', config)
-    if args:
-        build_args += ('--',)
-        build_args += tuple(args)
-    resultcode, lines = shell('cmake', build_args)
-
-    if resultcode:
-        print('Build FAILED:')
-        if not ARGS.verbose:
-            print(*lines, sep='')
-        sys.exit(1)
-
-def run_cmake_tests(directory, target, config):
-    failed = []
-    if IS_WINDOWS:
-        target += '.exe'
-    executable = os.path.join(directory, config if config else 'Debug', target)
-    if(not os.path.exists(executable)):
-        executable = os.path.join(directory, target)
-    print('Unit tests for', executable)
-    testflag = '--unittest'
-    quiet = ''
-    testjobs = ''
-    if ARGS.test:
-        testflag += ('=' + ARGS.test)
-    if ARGS.quiet:
-        quiet = '-q'
-    if ARGS.testjobs:
-        testjobs = ('--unittest-jobs=' + str(ARGS.testjobs))
-    resultcode, lines = shell(executable, (testflag, quiet, testjobs,))
-
-    if resultcode:
-        if not ARGS.verbose:
-            print('ERROR:', *lines, sep='')
-        failed.append([target, 'unittest'])
-
-    return failed
-
-def main():
-    all_failed = []
-    if ARGS.all:
-        build_dir_targets = CMAKE_DIR_TARGETS
-        generator_options = CMAKE_ALL_GENERATE_OPTIONS
-    else:
-        build_dir_targets = { tuple(ARGS.dir) : [ARGS.target, ARGS.config] }
-        if ARGS.generator_option:
-            generator_options = [tuple(ARGS.generator_option)]
-        else:
-            generator_options = [tuple()]
-
-    if not build_dir_targets:
-        # Let CMake choose the build tool.
-        build_dir_targets = { () : [] }
-
-    if ARGS.build_option:
-        ARGS.build_option = ARGS.build_option + list(ARGS.extra_args)
-    else:
-        ARGS.build_option = list(ARGS.extra_args)
-
-    for args in generator_options:
-        for build_dirs, (build_targets, build_configs) in build_dir_targets.items():
-            if not build_dirs:
-                build_dirs = ('default',)
-            if not build_targets:
-                build_targets = ('rippled',)
-            if not build_configs:
-                build_configs = ('',)
-            for cmake_dir in build_dirs:
-                cmake_full_dir = get_cmake_dir(cmake_dir)
-                run_cmake(cmake_full_dir, cmake_dir, args)
-
-                for target in build_targets:
-                    for config in build_configs:
-                        run_cmake_build(cmake_full_dir, target, config, ARGS.build_option)
-                        failed = run_cmake_tests(cmake_full_dir, target, config)
-
-                        if failed:
-                            print('FAILED:', *(':'.join(f) for f in failed))
-                            if not ARGS.keep_going:
-                                sys.exit(1)
-                            else:
-                                all_failed.extend([decodeString(cmake_dir +
-                                        "." + target + "." + config), ':'.join(f)]
-                                    for f in failed)
-                        else:
-                            print('Success')
-                if ARGS.clean:
-                    shutil.rmtree(cmake_full_dir)
-
-    if all_failed:
-        if len(all_failed) > 1:
-            print()
-            print('FAILED:', *(':'.join(f) for f in all_failed))
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()
-    sys.exit(0)

Builds/VisualStudio2017/CMakeSettings-example.json

@@ -1,45 +0,0 @@
-{
-  // See https://go.microsoft.com//fwlink//?linkid=834763 for more information about this file.
-  "configurations": [
-    {
-      "name": "x64-Debug",
-      "generator": "Visual Studio 15 2017 Win64",
-      "configurationType": "Debug",
-      "inheritEnvironments": [ "msvc_x64_x64" ],
-      "buildRoot": "${thisFileDir}\\build\\${name}",
-      "cmakeCommandArgs": "",
-      "buildCommandArgs": "-v:minimal",
-      "ctestCommandArgs": "",
-      "variables": [
-        {
-          "name": "BOOST_ROOT",
-          "value": "C:\\lib\\boost"
-        },
-        {
-          "name": "OPENSSL_ROOT",
-          "value": "C:\\lib\\OpenSSL-Win64"
-        }
-      ]
-    },
-    {
-      "name": "x64-Release",
-      "generator": "Visual Studio 15 2017 Win64",
-      "configurationType": "Release",
-      "inheritEnvironments": [ "msvc_x64_x64" ],
-      "buildRoot": "${thisFileDir}\\build\\${name}",
-      "cmakeCommandArgs": "",
-      "buildCommandArgs": "-v:minimal",
-      "ctestCommandArgs": "",
-      "variables": [
-        {
-          "name": "BOOST_ROOT",
-          "value": "C:\\lib\\boost"
-        },
-        {
-          "name": "OPENSSL_ROOT",
-          "value": "C:\\lib\\OpenSSL-Win64"
-        }
-      ]
-    }
-  ]
-}

Builds/VisualStudio2017/README.md

@@ -1,263 +0,0 @@
-# Visual Studio 2017 Build Instructions
-
-## Important
-
-We do not recommend Windows for rippled production use at this time. Currently,
-the Ubuntu platform has received the highest level of quality assurance,
-testing, and support. Additionally, 32-bit Windows versions are not supported.
-
-## Prerequisites
-
-To clone the source code repository, create branches for inspection or
-modification, build rippled under Visual Studio, and run the unit tests you will
-need these software components
-
-| Component | Minimum Recommended Version |
-|-----------|-----------------------|
-| [Visual Studio 2017](README.md#install-visual-studio-2017)| 15.5.4 |
-| [Git for Windows](README.md#install-git-for-windows)| 2.16.1|
-| [Google Protocol Buffers Compiler](README.md#install-google-protocol-buffers-compiler) | 2.5.1|
-| [OpenSSL Library](README.md#install-openssl) | 1.0.2n |
-| [Boost library](README.md#build-boost) | 1.66.0 |
-| [CMake for Windows](README.md#optional-install-cmake-for-windows)* | 3.10.2 |
-
-\* Only needed if not using the integrated CMake in VS 2017 and prefer generating dedicated project/solution files.
-
-## Install Software
-
-### Install Visual Studio 2017
-
-If not already installed on your system, download your choice of installer from
-the [Visual Studio 2017
-Download](https://www.visualstudio.com/downloads/download-visual-studio-vs)
-page, run the installer, and follow the directions. **You may need to choose the
-`Desktop development with C++` workload to install all necessary C++ features.**
-
-Any version of Visual Studio 2017 may be used to build rippled. The **Visual
-Studio 2017 Community** edition is available free of charge (see [the product
-page](https://www.visualstudio.com/products/visual-studio-community-vs) for
-licensing details), while paid editions may be used for an initial free-trial
-period.
-
-### Install Git for Windows
-
-Git is a distributed revision control system. The Windows version also provides
-the bash shell and many Windows versions of Unix commands. While there are other
-varieties of Git (such as TortoiseGit, which has a native Windows interface and
-integrates with the Explorer shell), we recommend installing [Git for
-Windows](https://git-scm.com/) since it provides a Unix-like command line
-environment useful for running shell scripts. Use of the bash shell under
-Windows is mandatory for running the unit tests.
-
-### Install Google Protocol Buffers Compiler
-
-Building rippled requires **protoc.exe** version 2. Version 3 is not currently
-supported.. At your option you may build it yourself from the sources in the
-[Google Protocol Buffers](https://github.com/google/protobuf) repository, or you
-may download a
-[protoc.exe](https://ripple.github.io/Downloads/protoc/2.5.1/protoc.exe)
-([alternate
-link](https://github.com/ripple/Downloads/raw/gh-pages/protoc/2.5.1/protoc.exe))
-precompiled Windows executable from the [Ripple
-Organization](https://github.com/ripple).
-
-Either way, once you have the required version of **protoc.exe**, copy it into a
-standard location that is in your command line `%PATH%`.
-
-* **NOTE:** If you use an older version of the compiler, the build will fail
-  with errors related to a mismatch of the version of protocol buffer headers
-  versus the compiler. Likewise, if you use version 3 or newer, the build will
-  fail.
-
-### Install OpenSSL
-
-[Download OpenSSL.](http://slproweb.com/products/Win32OpenSSL.html) There will
-four `Win64` bit variants available, you want the non-light `v1.0` line. As of
-this writing, you **should** select
-
-* Win64 OpenSSL v1.0.2n. 
-
-and should **not** select
-
-* Win64 OpenSSL v1.0.2n light
-* Win64 OpenSSL v1.1.0g
-* Win64 OpenSSL v1.1.0g light
-
-Run the installer, and choose an appropriate location for your OpenSSL
-installation. In this guide we use `C:\lib\OpenSSL-Win64` as the destination
-location.
-
-You may be informed on running the installer that "Visual C++ 2008
-Redistributables" must first be installed first. If so, download it from the
-[same page](http://slproweb.com/products/Win32OpenSSL.html), again making sure
-to get the correct 32-/64-bit variant.
-
-* NOTE: Since rippled links statically to OpenSSL, it does not matter where the
-  OpenSSL .DLL files are placed, or what version they are. rippled does not use
-  or require any external .DLL files to run other than the standard operating
-  system ones.
-
-### Build Boost
-
-After [downloading boost](http://www.boost.org/users/download/) and unpacking it
-to `c:\lib`. As of this writing, the most recent version of boost is 1.66.0,
-which will unpack into a directory named `boost_1_66_0`. We recommended either
-renaming this directory to `boost`, or creating a junction link `mklink /J boost
-boost_1_66_0`, so that you can more easily switch between versions.
-
-Next, open **Developer Command Prompt** and type the following commands
-
-```powershell
-cd C:\lib\boost
-bootstrap
-```
-
-The rippled application is linked statically to the standard runtimes and
-external dependencies on Windows, to ensure that the behavior of the executable
-is not affected by changes in outside files. Therefore, it is necessary to build
-the required boost static libraries using this command:
-
-```powershell
-bjam -j<Num Parallel> --toolset=msvc-14.1 address-model=64 architecture=x86 link=static threading=multi runtime-link=shared,static stage
-```
-
-where you should replace `<Num Parallel>` with the number of parallel
-invocations to use build, e.g. `bjam -j4 ...` would use up to 4 concurrent build
-shell commands for the build.
-
-Building the boost libraries may take considerable time. When the build process
-is completed, take note of both the reported compiler include paths and linker
-library paths as they will be required later.
-
-### (Optional) Install CMake for Windows
-
-[CMake](http://cmake.org) is a cross platform build system generator. Visual
-Studio 2017 includes an integrated version of CMake that avoids having to
-manually run CMake, but it is undergoing continuous improvement. Users that
-prefer to use standard Visual Studio project and solution files need to install
-a dedicated version of Cmake to generate them.  The latest version can be found
-at the [CMake download site](https://cmake.org/download/). It is recommended you
-select the install option to add CMake to your path.
-
-As of this writing, the latest version of CMake for windows is 3.10.2.
-
-## Clone the rippled repository
-
-If you are familiar with cloning github repositories, just follow your normal
-process and clone `git@github.com:ripple/rippled.git`. Otherwise follow this
-section for instructions.
-
-1. If you don't have a github account, sign up for one at
-   [github.com](https://github.com/).
-2. Make sure you have Github ssh keys. For help see
-   [generating-ssh-keys](https://help.github.com/articles/generating-ssh-keys).
-
-Open the "Git Bash" shell that was installed with "Git for Windows" in the step
-above. Navigate to the directory where you want to clone rippled (git bash uses
-`/c` for windows's `C:` and forward slash where windows uses backslash, so
-`C:\Users\joe\projs` would be `/c/Users/joe/projs` in git bash). Now clone the
-repository and optionally switch to the *master* branch. Type the following at
-the bash prompt:
-
-```powershell
-git clone git@github.com:ripple/rippled.git
-cd rippled
-```
-If you receive an error about not having the "correct access rights" make sure
-you have Github ssh keys, as described above.
-
-For a stable release, choose the `master` branch or one of the tagged releases
-listed on [rippled's GitHub page](https://github.com/ripple/rippled/releases). 
-
-```
-git checkout master
-```
-
-To test the latest release candidate, choose the `release` branch.
-
-```
-git checkout release
-```
-
-If you are doing development work and want the latest set of untested features,
-you can consider using the `develop` branch instead.
-
-```
-git checkout develop
-```
-
-# Build using Visual Studio integrated CMake
-
-In Visual Studio 2017, Microsoft added [integrated IDE support for
-cmake](https://blogs.msdn.microsoft.com/vcblog/2016/10/05/cmake-support-in-visual-studio/).
-To begin, simply:
-
-1. Launch Visual Studio and choose **File | Open | Folder**, navigating to the
-   cloned rippled folder.
-2. Right-click on `CMakeLists.txt` in the **Solution Explorer - Folder View** to
-   generate a `CMakeSettings.json` file. A sample settings file is provided
-   [here](/Builds/VisualStudio2017/CMakeSettings-example.json). Customize the 
-   settings for `BOOST_ROOT`, `OPENSSL_ROOT` to match the install paths if they
-   differ from those in the file.
-4. Select either the `x64-Release` or `x64-Debug` configuration from the
-   **Project Setings** drop-down. This should invoke the built-in CMake project
-   generator. If not, you can right-click on the `CMakeLists.txt` file and
-   choose **Cache | Generate Cache**.
-5. Select either the `rippled.exe` (unity) or `rippled_classic.exe` (non-unity)
-   option in the **Select Startup Item** drop-down. This will be the target
-   built when you press F7. Alternatively, you can choose a target to build from
-   the top-level **CMake | Build** menu. Note that at this time, there are other
-   targets listed that come from third party visual studio files embedded in the
-   rippled repo, e.g. `datagen.vcxproj`. Please ignore them.
-
-For details on configuring debugging sessions or further customization of CMake,
-please refer to the [CMake tools for VS
-documentation](https://docs.microsoft.com/en-us/cpp/ide/cmake-tools-for-visual-cpp).
-
-If using the provided `CMakeSettings.json` file, the executable will be in
-```
-.\build\x64-Release\Release\rippled(_classic).exe
-```
-or
-```
-.\build\x64-Debug\Debug\rippled(_classic).exe
-```
-where these paths are relative to your cloned git repository.
-
-# Build using stand-alone CMake
-
-This requires having installed [CMake for
-Windows](README.md#optional-install-cmake-for-windows). We do not recommend
-mixing this method with the integrated CMake method for the same repository
-clone. Assuming you included the cmake executable folder in your path,
-execute the following commands within your `rippled` cloned repository:
-
-```
-mkdir build\cmake
-cd build\cmake
-cmake ..\.. -G"Visual Studio 15 2017 Win64" -DBOOST_ROOT="C:\lib\boost_1_66_0" -DOPENSSL_ROOT="C:\lib\OpenSSL-Win64"
-```
-Now launch Visual Studio 2017 and select **File | Open | Project/Solution**.
-Navigate to the `build\cmake` folder created above and select the `rippled.sln`
-file. You can then choose whether to build the `Debug` or `Release` solution
-configuration. Within the **Solution Explorer**, selected either the `rippled`
-(unity build) project or the `rippled_classic` (non-unity) project, and
-right-click to build.
-
-The executable will be in 
-```
-.\build\cmake\Release\rippled(_classic).exe
-```
- or
-````
-.\build\cmake\Debug\rippled(_classic).exe
-````
-where these paths are relative to your cloned git repository.
-
-# Unit Test (Recommended)
-
-`rippled` builds a set of unit tests into the server executable. To run these
-unit tests after building, pass the `--unittest` option to the compiled
-`rippled` executable. The executable will exit with summary info after running
-the unit tests.
-

Builds/build_all.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-
-num_procs=$(lscpu -p | grep -v '^#' | sort -u -t, -k 2,4 | wc -l) # number of physical cores
-
-path=$(cd $(dirname $0) && pwd)
-cd $(dirname $path)
-${path}/Test.py -a -c --testjobs=${num_procs} -- -j${num_procs}

Builds/levelization/README.md

@@ -0,0 +1,114 @@
+# Levelization
+
+Levelization is the term used to describe efforts to prevent rippled from
+having or creating cyclic dependencies.
+
+rippled code is organized into directories under `src/rippled` (and
+`src/test`) representing modules. The modules are intended to be
+organized into "tiers" or "levels" such that a module from one level can
+only include code from lower levels. Additionally, a module
+in one level should never include code in an `impl` folder of any level
+other than it's own.
+
+Unfortunately, over time, enforcement of levelization has been
+inconsistent, so the current state of the code doesn't necessarily
+reflect these rules. Whenever possible, developers should refactor any
+levelization violations they find (by moving files or individual
+classes). At the very least, don't make things worse.
+
+The table below summarizes the _desired_ division of modules, based on the
+state of the rippled code when it was created. The levels are numbered from
+the bottom up with the lower level, lower numbered, more independent
+modules listed first, and the higher level, higher numbered modules with
+more dependencies listed later.
+
+**tl;dr:** The modules listed first are more independent than the modules
+listed later.
+
+| Level / Tier | Module(s)                                     |
+|--------------|-----------------------------------------------|
+| 01           | ripple/beast ripple/unity
+| 02           | ripple/basics
+| 03           | ripple/json ripple/crypto
+| 04           | ripple/protocol
+| 05           | ripple/core ripple/conditions ripple/consensus ripple/resource ripple/server
+| 06           | ripple/peerfinder ripple/ledger ripple/nodestore ripple/net
+| 07           | ripple/shamap ripple/overlay
+| 08           | ripple/app
+| 09           | ripple/rpc
+| 10           | ripple/perflog
+| 11           | test/jtx test/beast test/csf
+| 12           | test/unit_test
+| 13           | test/crypto test/conditions test/json test/resource test/shamap test/peerfinder test/basics test/overlay
+| 14           | test
+| 15           | test/net test/protocol test/ledger test/consensus test/core test/server test/nodestore
+| 16           | test/rpc test/app
+
+(Note that `test` levelization is *much* less important and *much* less
+strictly enforced than `ripple` levelization, other than the requirement
+that `test` code should *never* be included in `ripple` code.)
+
+## Validation
+
+The [levelization.sh](levelization.sh) script takes no parameters,
+reads no environment variables, and can be run from any directory,
+as long as it is in the expected location in the rippled repo.
+It can be run at any time from within a checked out repo, and will
+do an analysis of all the `#include`s in
+the rippled source. The only caveat is that it runs much slower
+under Windows than in Linux. It hasn't yet been tested under MacOS.
+It generates many files of [results](results):
+
+* `rawincludes.txt`: The raw dump of the `#includes`
+* `paths.txt`: A second dump grouping the source module
+  to the destination module, deduped, and with frequency counts.
+* `includes/`: A directory where each file represents a module and
+  contains a list of modules and counts that the module _includes_.
+* `includedby/`: Similar to `includes/`, but the other way around. Each
+  file represents a module and contains a list of modules and counts
+  that _include_ the module.
+* [`loops.txt`](results/loops.txt): A list of direct loops detected
+  between modules as they actually exist, as opposed to how they are
+  desired as described above. In a perfect repo, this file will be
+  empty.
+  This file is committed to the repo, and is used by the [levelization
+  Github workflow](../../.github/workflows/levelization.yml) to validate
+  that nothing changed.
+* [`ordering.txt`](results/ordering.txt): A list showing relationships
+  between modules where there are no loops as they actually exist, as
+  opposed to how they are desired as described above.
+  This file is committed to the repo, and is used by the [levelization
+  Github workflow](../../.github/workflows/levelization.yml) to validate
+  that nothing changed.
+* [`levelization.yml`](../../.github/workflows/levelization.yml)
+  Github Actions workflow to test that levelization loops haven't
+  changed.  Unfortunately, if changes are detected, it can't tell if
+  they are improvements or not, so if you have resolved any issues or
+  done anything else to improve levelization, run `levelization.sh`,
+  and commit the updated results.
+
+The  `loops.txt` and `ordering.txt` files relate the modules
+using comparison signs, which indicate the number of times each
+module is included in the other.
+
+* `A > B` means that A should probably be at a higher level than B,
+  because B is included in A significantly more than A is included in B.
+  These results can be included in both `loops.txt` and `ordering.txt`.
+  Because `ordering.txt`only includes relationships where B is not
+  included in A at all, it will only include these types of results.
+* `A ~= B` means that A and B are included in each other a different
+  number of times, but the values are so close that the script can't
+  definitively say that one should be above the other. These results
+  will only be included in `loops.txt`.
+* `A == B` means that A and B include each other the same number of
+  times, so the script has no clue which should be higher. These results
+  will only be included in `loops.txt`.
+
+The committed files hide the detailed values intentionally, to
+prevent false alarms and merging issues, and because it's easy to
+get those details locally.
+
+1. Run `levelization.sh`
+2. Grep the modules in `paths.txt`.
+   * For example, if a cycle is found `A ~= B`, simply `grep -w
+     A Builds/levelization/results/paths.txt | grep -w B`

Builds/levelization/levelization.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+
+# Usage: levelization.sh
+# This script takes no parameters, reads no environment variables,
+# and can be run from any directory, as long as it is in the expected
+# location in the repo.
+
+pushd $( dirname $0 )
+
+if [ -v PS1 ]
+then
+  # if the shell is interactive, clean up any flotsam before analyzing
+  git clean -ix
+fi
+
+# Ensure all sorting is ASCII-order consistently across platforms.
+export LANG=C
+
+rm -rfv results
+mkdir results
+includes="$( pwd )/results/rawincludes.txt"
+pushd ../..
+echo Raw includes:
+grep -r '^[ ]*#include.*/.*\.h' include src | \
+    grep -v boost | tee ${includes}
+popd
+pushd results
+
+oldifs=${IFS}
+IFS=:
+mkdir includes
+mkdir includedby
+echo Build levelization paths
+exec 3< ${includes} # open rawincludes.txt for input
+while read -r -u 3 file include
+do
+    level=$( echo ${file} | cut -d/ -f 2,3 )
+    # If the "level" indicates a file, cut off the filename
+    if [[ "${level##*.}" != "${level}" ]]
+    then
+        # Use the "toplevel" label as a workaround for `sort`
+        # inconsistencies between different utility versions
+        level="$( dirname ${level} )/toplevel"
+    fi
+    level=$( echo ${level} | tr '/' '.' )
+
+    includelevel=$( echo ${include} | sed 's/.*["<]//; s/[">].*//' | \
+        cut -d/ -f 1,2 )
+    if [[ "${includelevel##*.}" != "${includelevel}" ]]
+    then
+        # Use the "toplevel" label as a workaround for `sort`
+        # inconsistencies between different utility versions
+        includelevel="$( dirname ${includelevel} )/toplevel"
+    fi
+    includelevel=$( echo ${includelevel} | tr '/' '.' )
+
+    if [[ "$level" != "$includelevel" ]]
+    then
+        echo $level $includelevel | tee -a paths.txt
+    fi
+done
+echo Sort and dedup paths
+sort -ds paths.txt | uniq -c | tee sortedpaths.txt
+mv sortedpaths.txt paths.txt
+exec 3>&- #close fd 3
+IFS=${oldifs}
+unset oldifs
+
+echo Split into flat-file database
+exec 4<paths.txt # open paths.txt for input
+while read -r -u 4 count level include
+do
+    echo ${include} ${count} | tee -a includes/${level}
+    echo ${level} ${count} | tee -a includedby/${include}
+done
+exec 4>&- #close fd 4
+
+loops="$( pwd )/loops.txt"
+ordering="$( pwd )/ordering.txt"
+pushd includes
+echo Search for loops
+# Redirect stdout to a file
+exec 4>&1
+exec 1>"${loops}"
+for source in *
+do
+  if [[ -f "$source" ]]
+  then
+    exec 5<"${source}" # open for input
+    while read -r -u 5 include includefreq
+    do
+      if [[ -f $include ]]
+      then
+        if grep -q -w $source $include
+        then
+          if grep -q -w "Loop: $include $source" "${loops}"
+          then
+            continue
+          fi
+          sourcefreq=$( grep -w $source $include | cut -d\  -f2 )
+          echo "Loop: $source $include"
+          # If the counts are close, indicate that the two modules are
+          # on the same level, though they shouldn't be
+          if [[ $(( $includefreq - $sourcefreq )) -gt 3 ]]
+          then
+              echo -e "  $source > $include\n"
+          elif [[ $(( $sourcefreq - $includefreq )) -gt 3 ]]
+          then
+              echo -e "  $include > $source\n"
+          elif [[ $sourcefreq -eq $includefreq ]]
+          then
+              echo -e "  $include == $source\n"
+          else
+              echo -e "  $include ~= $source\n"
+          fi
+        else
+          echo "$source > $include" >> "${ordering}"
+        fi
+      fi
+    done
+    exec 5>&- #close fd 5
+  fi
+done
+exec 1>&4 #close fd 1
+exec 4>&- #close fd 4
+cat "${ordering}"
+cat "${loops}"
+popd
+popd
+popd

Builds/levelization/results/loops.txt

@@ -0,0 +1,42 @@
+Loop: test.jtx test.toplevel
+  test.toplevel > test.jtx
+
+Loop: test.jtx test.unit_test
+  test.unit_test == test.jtx
+
+Loop: xrpld.app xrpld.core
+  xrpld.app > xrpld.core
+
+Loop: xrpld.app xrpld.ledger
+  xrpld.app > xrpld.ledger
+
+Loop: xrpld.app xrpld.net
+  xrpld.app > xrpld.net
+
+Loop: xrpld.app xrpld.overlay
+  xrpld.overlay > xrpld.app
+
+Loop: xrpld.app xrpld.peerfinder
+  xrpld.peerfinder ~= xrpld.app
+
+Loop: xrpld.app xrpld.rpc
+  xrpld.rpc > xrpld.app
+
+Loop: xrpld.app xrpld.shamap
+  xrpld.app > xrpld.shamap
+
+Loop: xrpld.core xrpld.net
+  xrpld.net > xrpld.core
+
+Loop: xrpld.core xrpld.perflog
+  xrpld.perflog == xrpld.core
+
+Loop: xrpld.net xrpld.rpc
+  xrpld.rpc ~= xrpld.net
+
+Loop: xrpld.overlay xrpld.rpc
+  xrpld.rpc ~= xrpld.overlay
+
+Loop: xrpld.perflog xrpld.rpc
+  xrpld.rpc ~= xrpld.perflog
+

Builds/levelization/results/ordering.txt

@@ -0,0 +1,196 @@
+libxrpl.basics > xrpl.basics
+libxrpl.crypto > xrpl.basics
+libxrpl.json > xrpl.basics
+libxrpl.json > xrpl.json
+libxrpl.protocol > xrpl.basics
+libxrpl.protocol > xrpl.json
+libxrpl.protocol > xrpl.protocol
+libxrpl.resource > xrpl.basics
+libxrpl.resource > xrpl.json
+libxrpl.resource > xrpl.resource
+libxrpl.server > xrpl.basics
+libxrpl.server > xrpl.json
+libxrpl.server > xrpl.protocol
+libxrpl.server > xrpl.server
+test.app > test.jtx
+test.app > test.rpc
+test.app > test.toplevel
+test.app > test.unit_test
+test.app > xrpl.basics
+test.app > xrpld.app
+test.app > xrpld.core
+test.app > xrpld.ledger
+test.app > xrpld.nodestore
+test.app > xrpld.overlay
+test.app > xrpld.rpc
+test.app > xrpl.json
+test.app > xrpl.protocol
+test.app > xrpl.resource
+test.basics > test.jtx
+test.basics > test.unit_test
+test.basics > xrpl.basics
+test.basics > xrpld.perflog
+test.basics > xrpld.rpc
+test.basics > xrpl.json
+test.basics > xrpl.protocol
+test.beast > xrpl.basics
+test.conditions > xrpl.basics
+test.conditions > xrpld.conditions
+test.consensus > test.csf
+test.consensus > test.toplevel
+test.consensus > test.unit_test
+test.consensus > xrpl.basics
+test.consensus > xrpld.app
+test.consensus > xrpld.consensus
+test.consensus > xrpld.ledger
+test.consensus > xrpl.json
+test.core > test.jtx
+test.core > test.toplevel
+test.core > test.unit_test
+test.core > xrpl.basics
+test.core > xrpld.core
+test.core > xrpld.perflog
+test.core > xrpl.json
+test.core > xrpl.server
+test.csf > xrpl.basics
+test.csf > xrpld.consensus
+test.csf > xrpl.json
+test.csf > xrpl.protocol
+test.json > test.jtx
+test.json > xrpl.json
+test.jtx > xrpl.basics
+test.jtx > xrpld.app
+test.jtx > xrpld.core
+test.jtx > xrpld.ledger
+test.jtx > xrpld.net
+test.jtx > xrpld.rpc
+test.jtx > xrpl.json
+test.jtx > xrpl.protocol
+test.jtx > xrpl.resource
+test.jtx > xrpl.server
+test.ledger > test.jtx
+test.ledger > test.toplevel
+test.ledger > xrpl.basics
+test.ledger > xrpld.app
+test.ledger > xrpld.core
+test.ledger > xrpld.ledger
+test.ledger > xrpl.protocol
+test.nodestore > test.jtx
+test.nodestore > test.toplevel
+test.nodestore > test.unit_test
+test.nodestore > xrpl.basics
+test.nodestore > xrpld.core
+test.nodestore > xrpld.nodestore
+test.nodestore > xrpld.unity
+test.overlay > test.jtx
+test.overlay > test.toplevel
+test.overlay > test.unit_test
+test.overlay > xrpl.basics
+test.overlay > xrpld.app
+test.overlay > xrpld.overlay
+test.overlay > xrpld.peerfinder
+test.overlay > xrpld.shamap
+test.overlay > xrpl.protocol
+test.peerfinder > test.beast
+test.peerfinder > test.unit_test
+test.peerfinder > xrpl.basics
+test.peerfinder > xrpld.core
+test.peerfinder > xrpld.peerfinder
+test.peerfinder > xrpl.protocol
+test.protocol > test.toplevel
+test.protocol > xrpl.basics
+test.protocol > xrpl.json
+test.protocol > xrpl.protocol
+test.resource > test.unit_test
+test.resource > xrpl.basics
+test.resource > xrpl.resource
+test.rpc > test.jtx
+test.rpc > test.toplevel
+test.rpc > xrpl.basics
+test.rpc > xrpld.app
+test.rpc > xrpld.core
+test.rpc > xrpld.net
+test.rpc > xrpld.overlay
+test.rpc > xrpld.rpc
+test.rpc > xrpl.json
+test.rpc > xrpl.protocol
+test.rpc > xrpl.resource
+test.server > test.jtx
+test.server > test.toplevel
+test.server > test.unit_test
+test.server > xrpl.basics
+test.server > xrpld.app
+test.server > xrpld.core
+test.server > xrpld.rpc
+test.server > xrpl.json
+test.server > xrpl.server
+test.shamap > test.unit_test
+test.shamap > xrpl.basics
+test.shamap > xrpld.nodestore
+test.shamap > xrpld.shamap
+test.shamap > xrpl.protocol
+test.toplevel > test.csf
+test.toplevel > xrpl.json
+test.unit_test > xrpl.basics
+xrpl.json > xrpl.basics
+xrpl.protocol > xrpl.basics
+xrpl.protocol > xrpl.json
+xrpl.resource > xrpl.basics
+xrpl.resource > xrpl.json
+xrpl.resource > xrpl.protocol
+xrpl.server > xrpl.basics
+xrpl.server > xrpl.json
+xrpl.server > xrpl.protocol
+xrpld.app > test.unit_test
+xrpld.app > xrpl.basics
+xrpld.app > xrpld.conditions
+xrpld.app > xrpld.consensus
+xrpld.app > xrpld.nodestore
+xrpld.app > xrpld.perflog
+xrpld.app > xrpl.json
+xrpld.app > xrpl.protocol
+xrpld.app > xrpl.resource
+xrpld.conditions > xrpl.basics
+xrpld.conditions > xrpl.protocol
+xrpld.consensus > xrpl.basics
+xrpld.consensus > xrpl.json
+xrpld.consensus > xrpl.protocol
+xrpld.core > xrpl.basics
+xrpld.core > xrpl.json
+xrpld.core > xrpl.protocol
+xrpld.ledger > xrpl.basics
+xrpld.ledger > xrpl.json
+xrpld.ledger > xrpl.protocol
+xrpld.net > xrpl.basics
+xrpld.net > xrpl.json
+xrpld.net > xrpl.protocol
+xrpld.net > xrpl.resource
+xrpld.nodestore > xrpl.basics
+xrpld.nodestore > xrpld.core
+xrpld.nodestore > xrpld.unity
+xrpld.nodestore > xrpl.json
+xrpld.nodestore > xrpl.protocol
+xrpld.overlay > xrpl.basics
+xrpld.overlay > xrpld.core
+xrpld.overlay > xrpld.peerfinder
+xrpld.overlay > xrpld.perflog
+xrpld.overlay > xrpl.json
+xrpld.overlay > xrpl.protocol
+xrpld.overlay > xrpl.resource
+xrpld.overlay > xrpl.server
+xrpld.peerfinder > xrpl.basics
+xrpld.peerfinder > xrpld.core
+xrpld.peerfinder > xrpl.protocol
+xrpld.perflog > xrpl.basics
+xrpld.perflog > xrpl.json
+xrpld.rpc > xrpl.basics
+xrpld.rpc > xrpld.core
+xrpld.rpc > xrpld.ledger
+xrpld.rpc > xrpld.nodestore
+xrpld.rpc > xrpl.json
+xrpld.rpc > xrpl.protocol
+xrpld.rpc > xrpl.resource
+xrpld.rpc > xrpl.server
+xrpld.shamap > xrpl.basics
+xrpld.shamap > xrpld.nodestore
+xrpld.shamap > xrpl.protocol

Builds/linux/README.md

@@ -1,147 +0,0 @@
-# Linux Build Instructions
-
-This document focuses on building rippled for development purposes under recent
-Ubuntu linux distributions. To build rippled for Redhat, Fedora or Centos
-builds, including docker based builds for those distributions, please consult
-the [rippled-package-builder](https://github.com/ripple/rippled-package-builder)
-repository. 
-
-Development is regularly done on Ubuntu 16.04 or later. For non Ubuntu
-distributions, the steps below should work be installing the appropriate
-dependencies using that distribution's package management tools.
-
-## Dependencies
-
-Use `apt-get` to install the dependencies provided by the distribution
-
-```
-$ apt-get update
-$ apt-get install -y gcc g++ wget git cmake protobuf-compiler libprotobuf-dev libssl-dev
-```
-
-Advanced users can choose to install newer versions of gcc, or the clang compiler.
-At this time, rippled only supports protobuf version 2. Using version 3 of 
-protobuf will give errors.
-
-### Build Boost
-
-We recommend downloading and compiling a more recent version of boost than
-provided by the `boost-all-dev` package. After changing to the directory where
-you wish to download and compile boost, run
-
-``` 
-$ wget https://dl.bintray.com/boostorg/release/1.65.1/source/boost_1_65_1.tar.gz
-$ tar -xzf boost_1_65_1.tar.gz
-$ cd boost_1_65_1
-$ ./bootstrap.sh
-$ ./b2 headers
-$ ./b2 -j<Num Parallel>
-```
-
-### (Optional) Dependencies for Building Source Documentation
-
-Source code documentation is not required for running/debugging rippled. That
-said, the documentation contains some helpful information about specific
-components of the application. For more information on how to install and run
-the necessary components, see [this document](../../docs/README.md)
-
-## Build
-
-### Clone the rippled repository
-
-From a shell:
-
-```
-git clone git@github.com:ripple/rippled.git
-cd rippled
-```
-
-For a stable release, choose the `master` branch or one of the tagged releases
-listed on [GitHub](https://github.com/ripple/rippled/releases). 
-
-```
-git checkout master
-```
-
-or to test the latest release candidate, choose the `release` branch.
-
-```
-git checkout release
-```
-
-If you are doing development work and want the latest set of untested
-features, you can consider using the `develop` branch instead.
-
-```
-git checkout develop
-```
-
-### Configure Library Paths
-
-If you didn't persistently set the `BOOST_ROOT` environment variable to the
-directory in which you compiled boost, then you should set it temporarily.
-
-For example, you built Boost in your home directory `~/boost_1_65_1`, you
-would do for any shell in which you want to build:
-
-```
-export BOOST_ROOT=~/boost_1_65_1
-```
-
-Alternatively, you can add `DBOOST_ROOT=~/boost_1_65_1` to the command line when
-invoking `cmake`.
-
-### Generate and Build
-
-All builds should be done in a separate directory from the source tree root 
-(a subdirectory is fine). For example, from the root of the ripple source tree:
-
-```
-mkdir my_build
-cd my_build
-```
-
-followed by:
-
-```
-cmake -Dtarget=gcc.debug.unity ..
-```
-
-The target variable can be adjusted as needed for `gcc` vs `clang`, `debug` vs.
-`release` and `unity` vs. `nounity` builds. `unity` builds are typically faster 
-to compile but run the risk of ODR violations given that multiple compilation 
-units are merged together at compile time. `nounity` builds will take longer to
-compile but align more closely with language standards. 
-
-Once you have generated the build system, you can run the build via cmake:
-
-```
-cmake --build . -- -j <parallel jobs>
-```
-
-the `-j` parameter in this example tells the build tool to compile several
-files in parallel. This value should be chosen roughly based on the number of
-cores you have available and/or want to use for building.
-
-When the build completes succesfully, you will have a `rippled` executable in
-the current directory, which can be used to connect to the network (when
-properly configured) or to run unit tests.
-
-#### Options During Configuration:
-
-There are a number of config variables that our CMake files support. These
-can be added to the cmake generation command as needed:
-
-* `-Dassert=ON` to enable asserts
-* `-Djemalloc=ON` to enable jemalloc support for heap checking
-* `-Dsan=thread` to enable the thread sanitizer with clang
-* `-Dsan=address` to enable the address sanitizer with clang
-* `-Dstatic=ON` to enable static linking library dependencies
-
-## Unit Tests (Recommended)
-
-`rippled` builds a set of unit tests into the server executable. To run these unit
-tests after building, pass the `--unittest` option to the compiled `rippled`
-executable. The executable will exit with summary info after running the unit tests.
-
-

Builds/macos/README.md

@@ -1,206 +0,0 @@
-# macos Build Instructions
-
-## Important
-
-We don't recommend macos for rippled production use at this time. Currently, the
-Ubuntu platform has received the highest level of quality assurance and
-testing. That said, macos is suitable for many development/test tasks.
-
-## Prerequisites
-
-You'll need macos 10.8 or later.
-
-To clone the source code repository, create branches for inspection or
-modification, build rippled using clang, and run the system tests you will need
-these software components:
-
-* [XCode](https://developer.apple.com/xcode/)
-* [Homebrew](http://brew.sh/)
-* [Boost](http://boost.org/)
-* other misc utilities and libraries installed via homebrew
-
-## Install Software
-
-### Install XCode
-
-If not already installed on your system, download and install XCode using the
-appstore or by using [this link](https://developer.apple.com/xcode/).
-
-For more info, see "Step 1: Download and Install the Command Line Tools"
-[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
-
-The command line tools can be installed through the terminal with the command:
-
-```
-xcode-select --install
-```
-
-### Install Homebrew
-
-> "[Homebrew](http://brew.sh/) installs the stuff you need that Apple didn’t."
-
-Open a terminal and type:
-
-```
-ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
-```
-
-For more info, see "Step 2: Install Homebrew"
-[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac#step-2)
-
-### Install Dependencies Using Homebrew
-
-`brew` will generally install the latest stable version of any package, which
-should satisfy the the minimum version requirements for rippled.
-
-```
-brew update
-brew install git cmake pkg-config protobuf openssl ninja
-```
-
-### Build Boost
-
-We want to compile boost with clang/libc++
-
-Download [a release](https://dl.bintray.com/boostorg/release/1.66.0/source/boost_1_66_0.tar.bz2)
-
-Extract it to a folder, making note of where, open a terminal, then:
-
-```
-./bootstrap.sh
-./b2 cxxflags="-std=c++14"
-```
-
-Create an environment variable `BOOST_ROOT` in one of your `rc` files, pointing
-to the root of the extracted directory.
-
-### Dependencies for Building Source Documentation
-
-Source code documentation is not required for running/debugging rippled. That
-said, the documentation contains some helpful information about specific
-components of the application. For more information on how to install and run
-the necessary components, see [this document](../../docs/README.md)
-
-## Build
-
-### Clone the rippled repository
-
-From a shell:
-
-```
-git clone git@github.com:ripple/rippled.git
-cd rippled
-```
-
-For a stable release, choose the `master` branch or one of the tagged releases
-listed on [GitHub](https://github.com/ripple/rippled/releases GitHub). 
-
-```
-git checkout master
-```
-
-or to test the latest release candidate, choose the `release` branch.
-
-```
-git checkout release
-```
-
-If you are doing development work and want the latest set of untested
-features, you can consider using the `develop` branch instead.
-
-```
-git checkout develop
-```
-
-### Configure Library Paths
-
-If you didn't persistently set the `BOOST_ROOT` environment variable to the
-root of the extracted directory above, then you should set it temporarily.
-
-For example, assuming your username were `Abigail` and you extracted Boost
-1.66.0 in `/Users/Abigail/Downloads/boost_1_66_0`, you would do for any
-shell in which you want to build:
-
-```
-export BOOST_ROOT=/Users/Abigail/Downloads/boost_1_66_0
-```
-
-### Generate and Build
-
-For simple command line building we recommend using the *Unix Makefile* or
-*Ninja* generator with cmake. All builds should be done in a separate directory
-from the source tree root (a subdirectory is fine). For example, from the root
-of the ripple source tree:
-
-```
-mkdir my_build
-cd my_build
-```
-
-followed by:
-
-```
-cmake -G "Unix Makefiles" -Dtarget=clang.debug.unity ..
-```
-
-or
-
-```
-cmake -G "Ninja" -Dtarget=clang.debug.unity ..
-```
-
-The target variable can be adjusted as needed for `debug` vs. `release` and
-`unity` vs. `nounity` builds. `unity` builds are typically faster to compile
-but run the risk of ODR violations given that multiple compilation units are
-merged together at compile time. `nounity` builds will take longer to compile
-but align more closely with language standards. 
-
-Once you have generated the build system, you can run the build via cmake:
-
-```
-cmake --build . -- -j 4
-```
-
-the `-j` parameter in this example tells the build tool to compile several
-files in parallel. This value should be chosen roughly based on the number of
-cores you have available and/or want to use for building.
-
-When the build completes succesfully, you will have a `rippled` executable in
-the current directory, which can be used to connect to the network (when
-properly configured) or to run unit tests.
-
-If you prefer to have an XCode project to use for building, ask CMake to
-generate that instead:
-
-```
-cmake -GXcode ..
-```
-
-After generation succeeds, the xcode project file can be opened and used to
-build/debug. However, just as with other generators, cmake knows how to build
-using the xcode project as well:
-
-```
-cmake --build . -- -jobs 4
-```
-
-This will invoke the `xcodebuild` utility to compile the project. See `xcodebuild
---help` for details about build options.
-
-#### Options During Configuration:
-
-There are a number of config variables that our CMake files support. These
-can be added to the cmake generation command as needed:
-
-* `-Dassert=ON` to enable asserts
-* `-Djemalloc=ON` to enable jemalloc support for heap checking
-* `-Dsan=thread` to enable the thread sanitizer with clang
-* `-Dsan=address` to enable the address sanitizer with clang
-
-## Unit Tests (Recommended)
-
-`rippled` builds a set of unit tests into the server executable. To run these unit
-tests after building, pass the `--unittest` option to the compiled `rippled`
-executable. The executable will exit with summary info after running the unit tests.
-
-

CMakeLists.txt

@@ -1,505 +1,146 @@
-# cmake support for building rippled. The rippled specific settings
-# below can be set at the command line as `-D<setting>=<value>`.
-#
-# * `target` is a period separated tuple from the sets
-#    {gcc,clang,msvc} x {debug, release} x {unity, nounity} x {coverage} x {profile}
-#
-#     Example, build gcc debug nonunity build
-#       -Dtarget=gcc.debug.nounity
-#     Example, clang release unity build
-#       -Dtarget=clang.release.unity
-#     Example, visual studio debug unity build
-#       -Dtarget=msvc.release.unity
-#     Example, build gcc release unity build suited for profiling with perf
-#       -Dtarget=gcc.release.unity.profile
-#     Example, build gcc debug unity build suited for measuring code coverage
-#     with gcov
-#       -Dtarget=gcc.release.unity.coverage
-#
-#
-#   The default is a unity debug build using gcc (linux), clang (osx), and
-#   msvc (windows).
-#
-#   Note the generated Visual Studio solution will always have two projects,
-#   one unity and one non-unity. If the `target` is unity, the default project
-#   will be named `rippled` and second non-default (non-unity) project
-#   will be called `rippled_classic`. Likewise, if the `target` is non-unity,
-#   the project will have a default project called `rippled` (now non-unity)
-#   and second non-default (unity) project `rippled_unity`. In either
-#   case, only the `rippled` build will be enabled by default.
-#
-# * `assert` whether to enable asserts in release build
-#
-#      Example, enable asserts even in release builds
-#        -Dassert=True
-#
-#    Default is not to enable asserts in release builds.
-#
-# * `san` enable clang sanitizers
-#
-#     Example, enable thread sanitizer
-#       -Dsan=thread
-#     Example, enable address sanitizer
-#       -Dsan=address
-#
-# * `static`, on linux, link protobuf, openssl, libc++, and boost
-#   statically.
-#
-#     Example, enable static linking
-#       -Dstatic=True
-#
-# * `jemalloc`, on linux, enables jemalloc for heap profiling.
-#
-#    Example, enable jemalloc
-#      -Djemallc=True
-#
-#########################################################
-# CMAKE_C_COMPILER and CMAKE_CXX_COMPILER must be defined
-# before the project statement; However, the project
-# statement will clear CMAKE_BUILD_TYPE. CACHE variables,
-# along with the order of this code, are used to work
-# around these constraints.
-#
-# Don't put any code above or in this block, unless it
-# has similar constraints.
-cmake_minimum_required(VERSION 3.1.0)
-set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/Builds/CMake")
-include(CMakeFuncs)
-set(openssl_min 1.0.2)
-parse_target()
-project(rippled)
-#########################################################
+cmake_minimum_required(VERSION 3.16)
 
-if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
-  set(dir "build")
-  set(cmd "cmake")
-  if (target)
-    set(dir "${dir}/${target}")
-    set(cmd "${cmd} -Dtarget=${target}")
-  elseif(CMAKE_BUILD_TYPE)
-    set(dir "${dir}/${CMAKE_BUILD_TYPE}")
-    set(cmd "${cmd} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
-  else()
-    set(dir "${dir}/default")
-  endif()
-  set(cmd "${cmd} ${CMAKE_SOURCE_DIR}")
-
-  message(FATAL_ERROR "Builds are not allowed in ${CMAKE_SOURCE_DIR}.\n"
-    "Instead:\n"
-    "1) Remove the CMakeCache.txt file and CMakeFiles directory "
-   "from ${CMAKE_SOURCE_DIR}.\n"
-    "2) Create a directory to hold your build files, for example: ${dir}.\n"
-    "3) Change to that directory.\n"
-    "4) Run cmake targetting ${CMAKE_SOURCE_DIR}, for example: ${cmd}")
+if(POLICY CMP0074)
+  cmake_policy(SET CMP0074 NEW)
 endif()
-if("${CMAKE_GENERATOR}" MATCHES "Visual Studio" AND
-    NOT ("${CMAKE_GENERATOR}" MATCHES .*Win64.*))
-  message(FATAL_ERROR "Visual Studio 32-bit build is unsupported. Use
-    -G\"${CMAKE_GENERATOR} Win64\"")
+if(POLICY CMP0077)
+  cmake_policy(SET CMP0077 NEW)
 endif()
 
-setup_build_cache()
+# Fix "unrecognized escape" issues when passing CMAKE_MODULE_PATH on Windows.
+file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
-if(nonunity)
-    get_cmake_property(allvars VARIABLES)
-    string(REGEX MATCHALL "[^;]*(DEBUG|RELEASE)[^;]*" matchvars "${allvars}")
-    foreach(var IN LISTS matchvars)
-        string(REGEX REPLACE "(DEBUG|RELEASE)" "\\1CLASSIC" newvar ${var})
-        set(${newvar} ${${var}})
-    endforeach()
+project(xrpl)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-    get_cmake_property(allvars CACHE_VARIABLES)
-    string(REGEX MATCHALL "[^;]*(DEBUG|RELEASE)[^;]*" matchvars "${allvars}")
-    foreach(var IN LISTS matchvars)
-        string(REGEX REPLACE "(DEBUG|RELEASE)" "\\1CLASSIC" newvar ${var})
-        set(${newvar} ${${var}} CACHE STRING "Copied from ${var}")
-    endforeach()
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+    # GCC-specific fixes
+    add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
+    # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # Clang-specific fixes
+    add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
+elseif(MSVC)
+    # MSVC-specific fixes
+    add_compile_options(/wd4068) # Ignore unknown pragmas
 endif()
 
-determine_build_type()
-
-check_gcc4_abi()
-
-############################################################
-
-include_directories(
-  src
-  src/beast
-  src/beast/include
-  src/beast/extras
-  src/nudb/include
-  src/soci/src
-  src/soci/include)
-
-special_build_flags()
-
-############################################################
-
-use_boost(
-  # resist the temptation to alphabetize these. coroutine
-  # must come before context.
-  chrono
-  coroutine
-  context
-  date_time
-  filesystem
-  program_options
-  regex
-  serialization
-  system
-  thread)
-
-use_pthread()
-
-use_openssl(${openssl_min})
-
-use_protobuf()
-
-setup_build_boilerplate()
-
-############################################################
-
-if (is_clang)
-  set(rocks_db_system_header --system-header-prefix=rocksdb2)
-else()
-  unset(rocks_db_system_header)
-endif()
-
-set(soci_extra_includes
-  -I"${CMAKE_SOURCE_DIR}/"src/soci/src/core
-  -I"${CMAKE_SOURCE_DIR}/"src/soci/include/private
-  -I"${CMAKE_SOURCE_DIR}/"src/sqlite)
-
-############################################################
-
-# Unity sources
-prepend(beast_unity_srcs
-src/ripple/beast/unity/
-beast_insight_unity.cpp
-beast_net_unity.cpp
-beast_hash_unity.cpp
-beast_utility_unity.cpp)
-
-prepend(ripple_unity_srcs
-src/ripple/unity/
-app_consensus.cpp
-app_ledger.cpp
-app_ledger_impl.cpp
-app_main1.cpp
-app_main2.cpp
-app_misc.cpp
-app_misc_impl.cpp
-app_paths.cpp
-app_tx.cpp
-conditions.cpp
-consensus.cpp
-core.cpp
-basics.cpp
-crypto.cpp
-ledger.cpp
-net.cpp
-overlay1.cpp
-overlay2.cpp
-peerfinder.cpp
-json.cpp
-protocol.cpp
-resource.cpp
-rpcx1.cpp
-rpcx2.cpp
-shamap.cpp
-server.cpp)
-
-prepend(test_unity_srcs
-src/test/unity/
-app_test_unity1.cpp
-app_test_unity2.cpp
-basics_test_unity.cpp
-beast_test_unity1.cpp
-beast_test_unity2.cpp
-conditions_test_unity.cpp
-consensus_test_unity.cpp
-core_test_unity.cpp
-json_test_unity.cpp
-ledger_test_unity.cpp
-overlay_test_unity.cpp
-peerfinder_test_unity.cpp
-protocol_test_unity.cpp
-resource_test_unity.cpp
-rpc_test_unity.cpp
-server_test_unity.cpp
-server_status_test_unity.cpp
-shamap_test_unity.cpp
-jtx_unity1.cpp
-jtx_unity2.cpp
-csf_unity.cpp)
-
-list(APPEND rippled_src_unity ${beast_unity_srcs} ${ripple_unity_srcs} ${test_unity_srcs})
-
-add_with_props(rippled_src_unity src/test/unity/nodestore_test_unity.cpp
--I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
--I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
--I"${CMAKE_SOURCE_DIR}/"src/snappy/config
-${rocks_db_system_header})
-
-add_with_props(rippled_src_unity src/ripple/unity/nodestore.cpp
--I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
--I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
--I"${CMAKE_SOURCE_DIR}/"src/snappy/config
-${rocks_db_system_header})
-
-add_with_props(rippled_src_unity src/ripple/unity/soci_ripple.cpp ${soci_extra_includes})
-
-list(APPEND ripple_unity_srcs ${beast_unity_srcs} ${test_unity_srcs}
-src/ripple/unity/nodestore.cpp
-src/ripple/unity/soci_ripple.cpp
-src/test/unity/nodestore_test_unity.cpp)
-
-############################################################
-
-# Non-unity sources
-file(GLOB_RECURSE core_srcs src/ripple/core/*.cpp)
-add_with_props(rippled_src_nonunity "${core_srcs}"
-    -I"${CMAKE_SOURCE_DIR}/"src/soci/src/core
-    -I"${CMAKE_SOURCE_DIR}/"src/sqlite)
-
-set(non_unity_srcs ${core_srcs})
-
-foreach(curdir
-        beast/clock
-        beast/container
-        beast/hash
-        beast/insight
-        beast/net
-        beast/utility
-        app
-        basics
-        conditions
-        crypto
-        consensus
-        json
-        ledger
-        legacy
-        net
-        overlay
-        peerfinder
-        protocol
-        resource
-        rpc
-        server
-        shamap)
-    file(GLOB_RECURSE cursrcs src/ripple/${curdir}/*.cpp)
-    list(APPEND rippled_src_nonunity "${cursrcs}")
-    list(APPEND non_unity_srcs "${cursrcs}")
-endforeach()
-
-file(GLOB_RECURSE nodestore_srcs src/ripple/nodestore/*.cpp
-    src/test/nodestore/*.cpp)
-
-add_with_props(rippled_src_nonunity "${nodestore_srcs}"
-    -I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
-    -I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
-    -I"${CMAKE_SOURCE_DIR}/"src/snappy/config
-    ${rocks_db_system_header})
-
-list(APPEND non_unity_srcs "${nodestore_srcs}")
-
-# unit test sources
-foreach(curdir
-        app
-        basics
-        beast
-        conditions
-        consensus
-        core
-        csf
-        json
-        jtx
-        ledger
-        nodestore
-        overlay
-        peerfinder
-        protocol
-        resource
-        rpc
-        server
-        shamap
-        unit_test)
-    file(GLOB_RECURSE cursrcs src/test/${curdir}/*.cpp)
-    list(APPEND test_srcs "${cursrcs}")
-endforeach()
-
-add_with_props(rippled_src_nonunity "${test_srcs}"
-    -I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
-    -I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
-    -I"${CMAKE_SOURCE_DIR}/"src/snappy/config
-    ${rocks_db_system_header})
-
-list(APPEND non_unity_srcs "${test_srcs}")
-
-if(WIN32 OR is_xcode)
-    # Rippled headers. Only needed for IDEs.
-    file(GLOB_RECURSE rippled_headers src/*.h src/*.hpp *.md)
-    list(APPEND rippled_headers Builds/CMake/CMakeFuncs.cmake)
-    foreach(curdir
-            beast/asio
-            beast/core
-            beast/crypto
-            beast/cxx17
-            proto
-            validators
-            websocket)
-        file(GLOB_RECURSE cursrcs src/ripple/${curdir}/*.cpp)
-        list(APPEND rippled_headers "${cursrcs}")
-    endforeach()
-    list(APPEND rippled_src_nonunity "${rippled_headers}")
-
-    set_property(
-        SOURCE ${rippled_headers}
-        APPEND
-        PROPERTY HEADER_FILE_ONLY
-        true)
-        # Doesn't work
-        # $<OR:$<CONFIG:Debug>,$<CONFIG:Release>>)
-endif()
-
-if (WIN32 OR is_xcode)
-  # Documentation sources. Only needed for IDEs.
-  prepend(doc_srcs
-    docs/
-    source.dox)
-
-  file(GLOB_RECURSE other_docs docs/*.md)
-  list(APPEND doc_srcs "${other_docs}")
-  set_property(
-    SOURCE ${doc_srcs}
-    APPEND
-    PROPERTY HEADER_FILE_ONLY
-    true)
-    # Doesn't work
-    # $<OR:$<CONFIG:Debug>,$<CONFIG:Release>>)
-endif()
-
-############################################################
-
-add_with_props(rippled_src_all src/ripple/unity/soci.cpp
-  ${soci_extra_includes})
-
-if (NOT is_msvc)
-  set(no_unused_w -Wno-unused-function)
-else()
-  unset(no_unused_w)
-endif()
-
-add_with_props(rippled_src_all src/ripple/unity/secp256k1.cpp
-  -I"${CMAKE_SOURCE_DIR}/"src/secp256k1
-  ${no_unused_w}
-  )
-
-foreach(cursrc
-    src/ripple/unity/beast.cpp
-    src/ripple/unity/lz4.c
-    src/ripple/unity/protobuf.cpp
-    src/ripple/unity/ripple.proto.cpp)
-
-  add_with_props(rippled_src_all ${cursrc}
-    ${rocks_db_system_header}
-    )
-
-endforeach()
-
-if (NOT is_msvc)
-  set(extra_props -Wno-array-bounds)
-else()
-  unset(extra_props)
-endif()
-
-add_with_props(rippled_src_all src/sqlite/sqlite_unity.c
-  ${extra_props})
-
-add_with_props(rippled_src_all src/ripple/unity/ed25519_donna.c
-  -I"${CMAKE_SOURCE_DIR}/"src/ed25519-donna)
-
-if (is_gcc)
-  set(no_gcc_warnings -w)
-else()
-  unset(no_gcc_warnings)
-endif()
-
-add_with_props(rippled_src_all src/ripple/unity/rocksdb.cpp
-  -I"${CMAKE_SOURCE_DIR}/"src/rocksdb2
-  -I"${CMAKE_SOURCE_DIR}/"src/rocksdb2/include
-  -I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
-  -I"${CMAKE_SOURCE_DIR}/"src/snappy/config
-  ${no_gcc_warnings} ${rocks_db_system_header})
-
-if (NOT is_msvc)
-  set(no_unused_w -Wno-unused-function)
-endif()
-
-add_with_props(rippled_src_all src/ripple/unity/snappy.cpp
-  -I"${CMAKE_SOURCE_DIR}/"src/snappy/snappy
-  -I"${CMAKE_SOURCE_DIR}/"src/snappy/config
-  ${no_unused_w})
-
-list(APPEND rippled_src_unity "${rippled_src_all}")
-list(APPEND rippled_src_nonunity "${rippled_src_all}")
-
-############################################################
-
-if (WIN32 OR is_xcode)
-  group_sources(src)
-  group_sources(docs)
-  group_sources(Builds)
-endif()
-
-if(unity)
-    add_executable(rippled ${rippled_src_unity} ${PROTO_HDRS})
-    add_executable(rippled_classic EXCLUDE_FROM_ALL ${rippled_src_nonunity} ${PROTO_HDRS})
-    set(other_target rippled_classic)
-else()
-    add_executable(rippled ${rippled_src_nonunity} ${PROTO_HDRS})
-    add_executable(rippled_unity EXCLUDE_FROM_ALL ${rippled_src_unity} ${PROTO_HDRS})
-    set(other_target rippled_unity)
-endif()
-list(APPEND targets "rippled")
-list(APPEND targets ${other_target})
-# Not the same as EXCLUDE_FROM_ALL. Prevents Visual Studio from building the
-# other_target when the user builds the solution (default when pressing <F7>)
-set_property(TARGET ${other_target} PROPERTY EXCLUDE_FROM_DEFAULT_BUILD true)
-
-find_package(Doxygen)
-if(TARGET Doxygen::doxygen)
-    # read the source config and make a modified one
-    # that points the output files to our build directory
-    FILE(READ "${CMAKE_SOURCE_DIR}/docs/source.dox" dox_content)
-    string(REGEX REPLACE "[\t ]*OUTPUT_DIRECTORY[\t ]*=(.*)"
-        "OUTPUT_DIRECTORY=${CMAKE_BINARY_DIR}\n\\1"
-        new_config "${dox_content}")
-    FILE(WRITE "${CMAKE_BINARY_DIR}/source.dox" "${new_config}")
-    add_custom_target(docs
-        COMMAND "${DOXYGEN_EXECUTABLE}" "${CMAKE_BINARY_DIR}/source.dox"
-        BYPRODUCTS "${CMAKE_BINARY_DIR}/html_doc/index.html"
-        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/docs"
-        SOURCES "${doc_srcs}"
-    )
-else()
-    message(WARNING
-        "doxygen executable not found. docs target will not be buildable")
-    if(${CMAKE_VERSION} VERSION_LESS "3.9.0")
-        message("...consider updating to CMake 3.9.0 or greater for better doxygen support")
+# 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 rev-parse HEAD
+        OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
+    if(gch)
+        set(GIT_COMMIT_HASH "${gch}")
+        message(STATUS gch: ${GIT_COMMIT_HASH})
+        add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
     endif()
+
+    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse --abbrev-ref HEAD
+        OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
+    if(gb)
+        set(GIT_BRANCH "${gb}")
+        message(STATUS gb: ${GIT_BRANCH})
+        add_definitions(-DGIT_BRANCH="${GIT_BRANCH}")
+    endif()
+endif() #git
+
+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++")
+  add_link_options("-stdlib=libc++")
 endif()
 
-set_startup_project(rippled)
+include (CheckCXXCompilerFlag)
+include (FetchContent)
+include (ExternalProject)
+include (CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
+if (target)
+  message (FATAL_ERROR "The target option has been removed - use native cmake options to control build")
+endif ()
 
-foreach(target IN LISTS targets)
-    target_link_libraries(${target}
-      ${OPENSSL_LIBRARIES} ${PROTOBUF_LIBRARIES} ${SANITIZER_LIBRARIES})
+include(RippledSanity)
+include(RippledVersion)
+include(RippledSettings)
+# this check has to remain in the top-level cmake
+# because of the early return statement
+if (packages_only)
+  if (NOT TARGET rpm)
+    message (FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?")
+  endif()
+  return ()
+endif ()
+include(RippledCompiler)
+include(RippledInterface)
 
-    link_common_libraries(${target})
-endforeach()
-
-if (NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-  message(WARNING "Rippled requires a 64 bit target architecture.\n"
-    "The most likely cause of this warning is trying to build rippled with a 32-bit OS.")
+option(only_docs "Include only the docs target?" FALSE)
+include(RippledDocs)
+if(only_docs)
+  return()
 endif()
+
+###
+
+include(deps/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)
+add_subdirectory(external/antithesis-sdk)
+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)
+
+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)
+
+target_link_libraries(ripple_libs INTERFACE
+  ed25519::ed25519
+  lz4::lz4
+  OpenSSL::Crypto
+  OpenSSL::SSL
+  secp256k1::secp256k1
+  soci::soci
+  SQLite::SQLite3
+)
+
+# Work around changes to Conan recipe for now.
+if(TARGET nudb::core)
+  set(nudb nudb::core)
+elseif(TARGET NuDB::nudb)
+  set(nudb NuDB::nudb)
+else()
+  message(FATAL_ERROR "unknown nudb target")
+endif()
+target_link_libraries(ripple_libs INTERFACE ${nudb})
+
+if(coverage)
+  include(RippledCov)
+endif()
+
+set(PROJECT_EXPORT_SET RippleExports)
+include(RippledCore)
+include(RippledInstall)
+include(RippledValidatorKeys)

Jenkinsfile

@@ -1,539 +0,0 @@
-#!/usr/bin/env groovy
-
-import groovy.json.JsonOutput
-import java.text.*
-
-def all_status = [:]
-def commit_id = ''
-// this is not the actual token, but an ID/key into the jenkins
-// credential store which httpRequest can access.
-def github_cred = '6bd3f3b9-9a35-493e-8aef-975403c82d3e'
-//
-// root API url for our repo (default, overriden below)
-//
-String github_repo = 'https://api.github.com/repos/ripple/rippled'
-
-try {
-    stage ('Startup Checks') {
-        // here we check the commit author against collaborators
-        // we need a node to do this because readJSON requires
-        // a filesystem (although we just pass it text)
-        node {
-            checkout scm
-            commit_id = sh(
-                script: 'git rev-parse HEAD',
-                returnStdout: true)
-            commit_id = commit_id.trim()
-            echo "commit ID is ${commit_id}"
-            commit_log = sh (
-                 script: "git show --name-status ${commit_id}",
-                 returnStdout: true)
-            printGitInfo (commit_id, commit_log)
-            //
-            // NOTE this getUserRemoteConfigs call requires a one-time
-            // In-process Script Approval (configure jenkins). We need this
-            // to detect the remote repo to interact with via the github API.
-            //
-            def remote_url = scm.getUserRemoteConfigs()[0].getUrl()
-            if (remote_url) {
-                echo "GIT URL scm: $remote_url"
-                def fork = remote_url.tokenize('/')[2]
-                def repo = remote_url.tokenize('/')[3].split('\\.')[0]
-                echo "GIT FORK: $fork"
-                echo "GIT REPO: $repo"
-                github_repo = "https://api.github.com/repos/${fork}/${repo}"
-                echo "API URL REPO: $github_repo"
-            }
-
-            if (env.CHANGE_AUTHOR) {
-                //
-                // this means we have some sort of PR , so verify the author
-                //
-                echo "CHANGE AUTHOR ---> $CHANGE_AUTHOR"
-                echo "CHANGE TARGET ---> $CHANGE_TARGET"
-                echo "CHANGE ID ---> $CHANGE_ID"
-                //
-                // check the commit author against collaborators
-                // we need a node to do this because readJSON requires
-                // a filesystem (although we just pass it text)
-                //
-                def response = httpRequest(
-                    timeout: 10,
-                    authentication: github_cred,
-                    url: "${github_repo}/collaborators")
-                def collab_data = readJSON(
-                    text: response.content)
-                collab_found = false;
-                for (collaborator in collab_data) {
-                    if (collaborator['login'] == "$CHANGE_AUTHOR") {
-                        echo "$CHANGE_AUTHOR is a collaborator!"
-                        collab_found = true;
-                        break;
-                    }
-                }
-
-                if (! collab_found) {
-                    manager.addShortText(
-                        'Author of this change is not a collaborator!',
-                        'Crimson',
-                        'white',
-                        '0px',
-                        'white')
-                    all_status['startup'] =
-                        [false, 'Author Check', "$CHANGE_AUTHOR is not a collaborator!"]
-                    error "$CHANGE_AUTHOR does not appear to be a collaborator...bailing on this build"
-                }
-            }
-        }
-    }
-
-    stage ('Parallel Build') {
-        String[][] variants = [
-            ['coverage'],
-            ['docs'],
-            ['msvc.debug'],
-            // This one does not currently build (TBD):
-            //['msvc.debug.nounity'],
-            ['msvc.debug', '', 'PROJECT_NAME=rippled_classic'],
-            ['msvc.release'],
-            ['clang.debug.unity'],
-            ['clang.debug.unity', '', 'PARALLEL_TESTS=false'],
-            ['clang.debug.nounity'],
-            ['gcc.debug.unity'],
-            ['gcc.debug.nounity'],
-            ['clang.release.unity'],
-            ['gcc.release.unity'],
-            // add a static build just to make sure it works
-            ['gcc.debug.unity', '-Dstatic=true'],
-            // TODO - sanitizer runs currently fail
-            //['gcc.debug.nounity' , '-Dsan=address', 'PARALLEL_TESTS=false'],
-            //['gcc.debug.nounity' , '-Dsan=thread',  'PARALLEL_TESTS=false'],
-        ]
-
-        // create a map of all builds
-        // that we want to run. The map
-        // is string keys and node{} object values
-        def builds = [:]
-        for (int index = 0; index < variants.size(); index++) {
-            def bldtype = variants[index][0]
-            def cmake_extra = variants[index].size() > 1 ? variants[index][1] : ''
-            def bldlabel = bldtype + cmake_extra
-            def extra_env = variants[index].size() > 2 ? variants[index][2..-1] : []
-            for (int j = 0; j < extra_env.size(); j++) {
-                bldlabel += "_" + extra_env[j]
-            }
-            bldlabel = bldlabel.replace('-', '_')
-            bldlabel = bldlabel.replace(' ', '')
-            bldlabel = bldlabel.replace('=', '_')
-
-            def compiler = getFirstPart(bldtype)
-            def target = getSecondPart(bldtype)
-            def config = getFirstPart(target)
-            if (compiler == 'coverage' || compiler == 'docs') {
-                compiler = 'gcc'
-            }
-            def cc =
-                (compiler == 'clang') ? '/opt/llvm-5.0.1/bin/clang' : 'gcc'
-            def cxx =
-                (compiler == 'clang') ? '/opt/llvm-5.0.1/bin/clang++' : 'g++'
-            def ucc = isNoUnity(target) ? 'true' : 'false'
-            def node_type =
-                (compiler == 'msvc') ? 'rippled-win' : 'rippled-dev'
-            // the default disposition for parallel test..disabled
-            // for coverage, enabled otherwise. Can still be overridden
-            // by explicitly setting with extra env settings above.
-            def pt = (compiler == 'coverage') ? 'false' : 'true'
-
-            def env_vars = [
-                "TARGET=${target}",
-                "CONFIG_TYPE=${config}",
-                "COMPILER=${compiler}",
-                "PARALLEL_TESTS=${pt}",
-                'BUILD=cmake',
-                "BUILD_DIR=${bldlabel}",
-                "CMAKE_EXTRA_ARGS=${cmake_extra}",
-                'VERBOSE_BUILD=true']
-
-            builds[bldlabel] = {
-                node(node_type) {
-                    checkout scm
-                    dir ('build') {
-                        deleteDir()
-                    }
-                    def cdir = upDir(pwd())
-                    echo "BASEDIR: ${cdir}"
-                    echo "COMPILER: ${compiler}"
-                    echo "TARGET: ${target}"
-                    echo "CONFIG: ${config}"
-                    echo "USE_CC: ${ucc}"
-                    if (compiler == 'msvc') {
-                        env_vars.addAll([
-                            'BOOST_ROOT=c:\\lib\\boost_1_66',
-                            'PROJECT_NAME=rippled',
-                            'MSBUILDDISABLENODEREUSE=1',  // this ENV setting is probably redundant since we also pass /nr:false to msbuild
-                            'OPENSSL_ROOT=c:\\OpenSSL-Win64'])
-                    }
-                    else {
-                        env_vars.addAll([
-                            'NINJA_BUILD=false',
-                            "CCACHE_BASEDIR=${cdir}",
-                            'PLANTUML_JAR=/opt/plantuml/plantuml.jar',
-                            'CCACHE_NOHASHDIR=true',
-                            "CC=${cc}",
-                            "CXX=${cxx}",
-                            'LCOV_ROOT=""',
-                            'PATH+CMAKE_BIN=/opt/local/cmake',
-                            'GDB_ROOT=/opt/local/gdb',
-                            'BOOST_ROOT=/opt/local/boost_1_66_0',
-                            "USE_CCACHE=${ucc}"])
-                    }
-
-                    if (extra_env.size() > 0) {
-                        env_vars.addAll(extra_env)
-                    }
-
-                    withCredentials(
-                        [string(
-                            credentialsId: 'RIPPLED_CODECOV_TOKEN',
-                            variable: 'CODECOV_TOKEN')])
-                    {
-                        withEnv(env_vars) {
-                            myStage(bldlabel)
-                            try {
-                                if (compiler == 'msvc') {
-                                    powershell "Remove-Item -Path \"${bldlabel}.txt\" -Force -ErrorAction Ignore"
-                                    // we capture stdout to variable because I could
-                                    // not figure out how to make powershell redirect internally
-                                    output = powershell (
-                                            returnStdout: true,
-                                            script: '''
-# Enable streams 3-6
-$WarningPreference = 'Continue'
-$VerbosePreference = 'Continue'
-$DebugPreference = 'Continue'
-$InformationPreference = 'Continue'
-
-Invoke-BatchFile "${env:ProgramFiles(x86)}\\Microsoft Visual Studio\\2017\\Community\\VC\\Auxiliary\\Build\\vcvarsall.bat" x86_amd64
-Get-ChildItem env:* | Sort-Object name
-cl
-cmake --version
-New-Item -ItemType Directory -Force -Path "build/$env:BUILD_DIR" -ErrorAction Stop
-$sw = [Diagnostics.Stopwatch]::StartNew()
-try {
-    Push-Location "build/$env:BUILD_DIR"
-    if ($env:NINJA_BUILD -eq "true") {
-        cmake -G"Ninja" -Dtarget="$env:COMPILER.$env:TARGET" -DCMAKE_VERBOSE_MAKEFILE=ON ../..
-    }
-    else {
-        cmake -G"Visual Studio 15 2017 Win64" -Dtarget="$env:COMPILER.$env:TARGET" -DCMAKE_VERBOSE_MAKEFILE=ON ../..
-    }
-    if ($LastExitCode -ne 0) { throw "CMake failed" }
-
-    ## as of 01/2018, DO NOT USE cmake to run the actual build step. for some
-    ## reason, cmake spawning the build under jenkins causes MSBUILD/ninja to
-    ## get stuck at the end of the build. Perhaps cmake is spawning
-    ## incorrectly or failing to pass certain params
-
-    if ($env:NINJA_BUILD -eq "true") {
-        ninja -j $env:NUMBER_OF_PROCESSORS -v
-    }
-    else {
-        msbuild /fl /m /nr:false /p:Configuration="$env:CONFIG_TYPE" /p:Platform=x64 /p:GenerateFullPaths=True /v:normal /nologo /clp:"ShowCommandLine;DisableConsoleColor" "$env:PROJECT_NAME.vcxproj"
-    }
-    if ($LastExitCode -ne 0) { throw "CMake build failed" }
-
-    $exe = "./$env:CONFIG_TYPE/$env:PROJECT_NAME"
-    if ($env:NINJA_BUILD -eq "true") {
-        $exe = "./$env:PROJECT_NAME"
-    }
-    "Exe is at $exe"
-    $params = '--unittest', '--quiet', '--unittest-log'
-    if ($env:PARALLEL_TESTS -eq "true") {
-        $params = $params += "--unittest-jobs=$env:NUMBER_OF_PROCESSORS"
-    }
-    & $exe $params
-    if ($LastExitCode -ne 0) { throw "Unit tests failed" }
-}
-catch {
-    throw
-}
-finally {
-    $sw.Stop()
-    $sw.Elapsed
-    Pop-Location
-}
-''')
-                                    // if the powershell command fails (has nonzero exit)
-                                    // then the command above throws, we don't get our output,
-                                    // and we never create this output file.
-                                    //  SEE https://issues.jenkins-ci.org/browse/JENKINS-44930
-                                    // Alternatively, figure out how to reliably redirect
-                                    // all output above to a file (Start/Stop transcript does not work)
-                                    writeFile(
-                                        file: "${bldlabel}.txt",
-                                        text: output)
-                                }
-                                else {
-                                    sh "rm -fv ${bldlabel}.txt"
-                                    // execute the bld command in a redirecting shell
-                                    // to capture output
-                                    sh '''\
-#!/bin/bash
-set -ex
-log_file=''' + "${bldlabel}.txt" + '''
-exec 3>&1 1>>${log_file} 2>&1
-ccache -s
-source /opt/rh/devtoolset-6/enable
-/usr/bin/time -p ./bin/ci/ubuntu/build-and-test.sh 2>&1
-ccache -s
-'''
-                                }
-                            }
-                            finally {
-                                def outstr = ''
-                                def loglink = '[console](' + env.BUILD_URL + '/console)'
-                                def logfile = "${bldlabel}.txt"
-                                if (fileExists(logfile)) {
-                                    outstr = readFile(logfile)
-                                    loglink = "[logfile](" + env.BUILD_URL + "/artifact/${logfile})"
-                                }
-                                def st = getResults(outstr, bldlabel)
-                                def time = getTime(outstr, bldlabel)
-                                def fail_count = getFailures(outstr, bldlabel)
-                                outstr = null
-                                def txtcolor =
-                                    fail_count == 0 ? 'DarkGreen' : 'Crimson'
-                                def shortbld = bldlabel
-                                shortbld = shortbld.replace('debug', 'dbg')
-                                shortbld = shortbld.replace('release', 'rel')
-                                shortbld = shortbld.replace('unity', 'un')
-                                manager.addShortText(
-                                    "${shortbld}: ${st}, t: ${time}",
-                                    txtcolor,
-                                    'white',
-                                    '0px',
-                                    'white')
-                                archive("${bldlabel}.txt")
-                                if (bldtype == 'docs') {
-                                    publishHTML(
-                                        allowMissing: true,
-                                        alwaysLinkToLastBuild: false,
-                                        keepAll: true,
-                                        reportName:  'Doxygen',
-                                        reportDir:   'build/docs/html_doc',
-                                        reportFiles: 'index.html')
-                                }
-                                def envs = ''
-                                for (int j = 0; j < extra_env.size(); j++) {
-                                    envs += ", <br/>" + extra_env[j]
-                                }
-                                def cmake_txt = cmake_extra
-                                if (cmake_txt != '') {
-                                    cmake_txt = " <br/>" + cmake_txt
-                                }
-                                lock('rippled_dev_status') {
-                                    all_status[bldlabel] =
-                                        [fail_count == 0, bldtype + cmake_txt + envs, "${st}, t: ${time}", loglink]
-                                }
-                            } //try-catch-finally
-                        } //withEnv
-                    } //withCredentials
-                } //node
-            } //builds item
-        } //for variants
-
-        // this actually executes all the builds we just defined
-        // above, in parallel as slaves are available
-        parallel builds
-    }
-}
-finally {
-    // anything here should run always...
-    stage ('Final Status') {
-        node {
-            def start_time = new Date()
-            def sdf = new SimpleDateFormat('yyyyMMdd - HH:mm:ss')
-            def datestamp = sdf.format(start_time)
-
-            def results = """
-## Jenkins Build Summary
-
-Built from [this commit](https://github.com/ripple/rippled/commit/${commit_id})
-
-Built at __${datestamp}__
-
-### Test Results
-
-Build Type | Log | Result | Status
----------- | --- | ------ | ------
-"""
-            for ( e in all_status) {
-                results += e.value[1] + ' | ' + e.value[3] + ' | ' + e.value[2] + ' | ' +
-                    (e.value[0] ? 'PASS :white_check_mark: ' : 'FAIL :red_circle: ') + '\n'
-            }
-            results += '\n'
-            echo 'FINAL BUILD RESULTS'
-            echo results
-
-            try {
-                def url_comment = ''
-                if (env.CHANGE_ID && env.CHANGE_ID ==~ /\d+/) {
-                    //
-                    // CHANGE_ID indicates we are building a PR
-                    // find PR comments
-                    //
-                    def resp = httpRequest(
-                        timeout: 10,
-                        authentication: github_cred,
-                        url: "${github_repo}/pulls/$CHANGE_ID")
-                    def result = readJSON(text: resp.content)
-                    //
-                    // follow issue comments link
-                    //
-                    url_comment = result['_links']['issue']['href'] + '/comments'
-                }
-                else {
-                    //
-                    // if not a PR, just search comments for our commit ID
-                    //
-                    url_comment =
-                        "${github_repo}/commits/${commit_id}/comments"
-                }
-
-                def response = httpRequest(
-                    timeout: 10,
-                    authentication: github_cred,
-                    url: url_comment)
-                def data = readJSON(text: response.content)
-                def comment_id = 0
-                def mode = 'POST'
-                // see if we can find and existing comment here with
-                // a heading that matches ours...
-                for (comment in data) {
-                    if (comment['body'] =~ /(?m)^##\s+Jenkins Build/) {
-                        comment_id = comment['id']
-                        echo "existing status comment ${comment_id} found"
-                        url_comment = comment['url']
-                        mode = 'PATCH'
-                        break;
-                    }
-                }
-
-                if (comment_id == 0) {
-                    echo 'no existing status comment found'
-                }
-
-                def body = JsonOutput.toJson([
-                    body: results
-                ])
-
-                response = httpRequest(
-                    timeout: 10,
-                    authentication: github_cred,
-                    url: url_comment,
-                    contentType: 'APPLICATION_JSON',
-                    httpMode: mode,
-                    requestBody: body)
-            }
-            catch (e) {
-                echo 'had a problem interacting with github...status is probably not updated'
-            }
-        }
-    }
-}
-
-// ---------------
-// util functions
-// ---------------
-def myStage(name) {
-    echo """
-+++++++++++++++++++++++++++++++++++++++++
-  >> building ${name}
-+++++++++++++++++++++++++++++++++++++++++
-"""
-}
-
-def printGitInfo(id, log) {
-    echo """
-+++++++++++++++++++++++++++++++++++++++++
-  >> Building commit ID ${id}
-  >>
-${log}
-+++++++++++++++++++++++++++++++++++++++++
-"""
-}
-
-@NonCPS
-def getResults(text, label) {
-    // example:
-    ///   194.5s, 154 suites, 948 cases, 360485 tests total, 0 failures
-    // or build log format:
-    //    [msvc.release] 71.3s, 162 suites, 995 cases, 318901 tests total, 1 failure
-    def matcher =
-        text == '' ?
-        manager.getLogMatcher(/\[${label}\].+?(\d+) case[s]?, (\d+) test[s]? total, (\d+) (failure(s?))/) :
-        text =~ /(\d+) case[s]?, (\d+) test[s]? total, (\d+) (failure(s?))/
-    matcher ? matcher[0][1] + ' cases, ' + matcher[0][3] + ' failed' : 'no test results'
-}
-
-def getFailures(text, label) {
-    // [see above for format]
-    def matcher =
-        text == '' ?
-        manager.getLogMatcher(/\[${label}\].+?(\d+) test[s]? total, (\d+) (failure(s?))/) :
-        text =~ /(\d+) test[s]? total, (\d+) (failure(s?))/
-    // if we didn't match, then return 1 since something is
-    // probably wrong, e.g. maybe the build failed...
-    matcher ? matcher[0][2] as Integer : 1i
-}
-
-@NonCPS
-def getTime(text, label) {
-    // look for text following a label 'real' for
-    // wallclock time. Some `time`s report fractional
-    // seconds and we can omit those in what we report
-    def matcher =
-        text == '' ?
-        manager.getLogMatcher(/(?m)^\[${label}\]\s+real\s+(.+)\.(\d+?)[s]?/) :
-        text =~ /(?m)^real\s+(.+)\.(\d+?)[s]?/
-    if (matcher) {
-        return matcher[0][1] + 's'
-    }
-
-    // alternatively, look for powershell elapsed time
-    // format, e.g. :
-    //    TotalSeconds      : 523.2140529
-    def matcher2 =
-        text == '' ?
-        manager.getLogMatcher(/(?m)^\[${label}\]\s+TotalSeconds\s+:\s+(\d+)\.(\d+?)?/) :
-        text =~ /(?m)^TotalSeconds\s+:\s+(\d+)\.(\d+?)?/
-    matcher2 ? matcher2[0][1] + 's' : 'n/a'
-}
-
-@NonCPS
-def getFirstPart(bld) {
-    def matcher = bld =~ /^(.+?)\.(.+)$/
-    matcher ? matcher[0][1] : bld
-}
-
-@NonCPS
-def isNoUnity(bld) {
-    def matcher = bld =~ /\.nounity\s*$/
-    matcher ? true : false
-}
-
-@NonCPS
-def getSecondPart(bld) {
-    def matcher = bld =~ /^(.+?)\.(.+)$/
-    matcher ? matcher[0][2] : bld
-}
-
-// because I can't seem to find path manipulation
-// functions in groovy....
-@NonCPS
-def upDir(path) {
-    def matcher = path =~ /^(.+)\/(.+?)/
-    matcher ? matcher[0][1] : path
-}
-
-

LICENSE.md

@@ -0,0 +1,17 @@
+ISC License 
+
+Copyright (c) 2011, Arthur Britto, David Schwartz, Jed McCaleb, Vinnie Falco, Bob Way, Eric Lombrozo, Nikolaos D. Bougalis, Howard Hinnant.
+Copyright (c) 2012-2020, the XRP Ledger developers.
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+

README.md

@@ -1,96 +1,69 @@
-# What is Ripple?
+# The XRP Ledger
 
-![Ripple](docs/images/ripple.png)
+The [XRP Ledger](https://xrpl.org/) is a decentralized cryptographic ledger powered by a network of peer-to-peer nodes. The XRP Ledger uses a novel Byzantine Fault Tolerant consensus algorithm to settle and record transactions in a secure distributed database without a central operator.
 
-> **Do you work at a digital asset exchange or wallet provider?** 
->
-> Please [contact us](mailto:support@ripple.com). We can help guide your integration.
+## XRP
+[XRP](https://xrpl.org/xrp.html) is a public, counterparty-free asset native to the XRP Ledger, and is designed to bridge the many different currencies in use worldwide. XRP is traded on the open-market and is available for anyone to access. The XRP Ledger was created in 2012 with a finite supply of 100 billion units of XRP.
 
-Ripple is a network of computers which use the [Ripple consensus algorithm](https://www.youtube.com/watch?v=pj1QVb1vlC0) to atomically settle and record
-transactions on a secure distributed database, the Ripple Consensus Ledger
-(RCL). Because of its distributed nature, the RCL offers transaction immutability
-without a central operator. The RCL contains a built-in currency exchange and its
-path-finding algorithm finds competitive exchange rates across order books
-and currency pairs.
+## rippled
+The server software that powers the XRP Ledger is called `rippled` and is available in this repository under the permissive [ISC open-source license](LICENSE.md). The `rippled` server software is written primarily in C++ and runs on a variety of platforms. The `rippled` server software can run in several modes depending on its [configuration](https://xrpl.org/rippled-server-modes.html).
 
-### Key Features
-- **Distributed**
-  - Direct account-to-account settlement with no central operator
-  - Decentralized global market for competitive FX
-- **Secure**
-  - Transactions are cryptographically signed using ECDSA or Ed25519
-  - Multi-signing capabilities
-- **Scalable**
-  - Capacity to process the world’s cross-border payments volume
-  - Easy access to liquidity through a competitive FX marketplace
+If you are interested in running an **API Server** (including a **Full History Server**), take a look at [Clio](https://github.com/XRPLF/clio). (rippled Reporting Mode has been replaced by Clio.)
 
-## Cross-border payments
-Ripple enables banks to settle cross-border payments in real-time, with
-end-to-end transparency, and at lower costs. Banks can provide liquidity
-for FX themselves or source it from third parties.
+### Build from Source
 
-As Ripple adoption grows, so do the number of currencies and counterparties.
-Liquidity providers need to maintain accounts with each counterparty for
-each currency – a capital- and time-intensive endeavor that spreads liquidity
-thin. Further, some transactions, such as exotic currency trades, will require
-multiple trading parties, who each layer costs to the transaction. Thin
-liquidity and many intermediary trading parties make competitive pricing
-challenging.
+* [Read the build instructions in `BUILD.md`](BUILD.md)
+* If you encounter any issues, please [open an issue](https://github.com/XRPLF/rippled/issues)
 
-![Flow - Direct](docs/images/flow1.png)
+## Key Features of the XRP Ledger
 
-### XRP as a Bridge Currency
-Ripple can bridge even exotic currency pairs directly through XRP. Similar to
-USD in today’s currency market, XRP allows liquidity providers to focus on
-offering competitive FX rates on fewer pairs and adding depth to order books.
-Unlike USD, trading through XRP does not require bank accounts, service fees,
-counterparty risk, or additional operational costs. By using XRP, liquidity
-providers can specialize in certain currency corridors, reduce operational
-costs, and ultimately, offer more competitive FX pricing.
+- **[Censorship-Resistant Transaction Processing][]:** No single party decides which transactions succeed or fail, and no one can "roll back" a transaction after it completes. As long as those who choose to participate in the network keep it healthy, they can settle transactions in seconds.
+- **[Fast, Efficient Consensus Algorithm][]:** The XRP Ledger's consensus algorithm settles transactions in 4 to 5 seconds, processing at a throughput of up to 1500 transactions per second. These properties put XRP at least an order of magnitude ahead of other top digital assets.
+- **[Finite XRP Supply][]:** When the XRP Ledger began, 100 billion XRP were created, and no more XRP will ever be created. The available supply of XRP decreases slowly over time as small amounts are destroyed to pay transaction costs.
+- **[Responsible Software Governance][]:** A team of full-time, world-class developers at Ripple maintain and continually improve the XRP Ledger's underlying software with contributions from the open-source community. Ripple acts as a steward for the technology and an advocate for its interests, and builds constructive relationships with governments and financial institutions worldwide.
+- **[Secure, Adaptable Cryptography][]:** The XRP Ledger relies on industry standard digital signature systems like ECDSA (the same scheme used by Bitcoin) but also supports modern, efficient algorithms like Ed25519. The extensible nature of the XRP Ledger's software makes it possible to add and disable algorithms as the state of the art in cryptography advances.
+- **[Modern Features for Smart Contracts][]:** Features like Escrow, Checks, and Payment Channels support cutting-edge financial applications including the [Interledger Protocol](https://interledger.org/). This toolbox of advanced features comes with safety features like a process for amending the network and separate checks against invariant constraints.
+- **[On-Ledger Decentralized Exchange][]:** In addition to all the features that make XRP useful on its own, the XRP Ledger also has a fully-functional accounting system for tracking and trading obligations denominated in any way users want, and an exchange built into the protocol. The XRP Ledger can settle long, cross-currency payment paths and exchanges of multiple currencies in atomic transactions, bridging gaps of trust with XRP.
 
-![Flow - Bridged over XRP](docs/images/flow2.png)
+[Censorship-Resistant Transaction Processing]: https://xrpl.org/xrp-ledger-overview.html#censorship-resistant-transaction-processing
+[Fast, Efficient Consensus Algorithm]: https://xrpl.org/xrp-ledger-overview.html#fast-efficient-consensus-algorithm
+[Finite XRP Supply]: https://xrpl.org/xrp-ledger-overview.html#finite-xrp-supply
+[Responsible Software Governance]: https://xrpl.org/xrp-ledger-overview.html#responsible-software-governance
+[Secure, Adaptable Cryptography]: https://xrpl.org/xrp-ledger-overview.html#secure-adaptable-cryptography
+[Modern Features for Smart Contracts]: https://xrpl.org/xrp-ledger-overview.html#modern-features-for-smart-contracts
+[On-Ledger Decentralized Exchange]: https://xrpl.org/xrp-ledger-overview.html#on-ledger-decentralized-exchange
 
-# rippled - Ripple server
-`rippled` is the reference server implementation of the Ripple
-protocol. To learn more about how to build and run a `rippled`
-server, visit https://ripple.com/build/rippled-setup/
 
-[![travis-ci.org: Build Status](https://travis-ci.org/ripple/rippled.png?branch=develop)](https://travis-ci.org/ripple/rippled)
-[![codecov.io: Code Coverage](https://codecov.io/gh/ripple/rippled/branch/develop/graph/badge.svg)](https://codecov.io/gh/ripple/rippled)
+## Source Code
 
-### License
-`rippled` is open source and permissively licensed under the
-ISC license. See the LICENSE file for more details.
+Here are some good places to start learning the source code:
 
-#### Repository Contents
+- Read the markdown files in the source tree: `src/ripple/**/*.md`.
+- Read [the levelization document](./Builds/levelization) to get an idea of the internal dependency graph.
+- In the big picture, the `main` function constructs an `ApplicationImp` object, which implements the `Application` virtual interface. Almost every component in the application takes an `Application&` parameter in its constructor, typically named `app` and stored as a member variable `app_`. This allows most components to depend on any other component.
 
-| Folder  | Contents |
-|---------|----------|
-| ./bin   | Scripts and data files for Ripple integrators. |
-| ./build | Intermediate and final build outputs.          |
-| ./Builds| Platform-specific guides for building rippled. |
-| ./docs  | Source documentation files and doxygen config. |
-| ./cfg   | Example configuration files.                   |
-| ./src   | Source code.                                   |
+### Repository Contents
 
-Some of the directories under `src` are external repositories inlined via
-git-subtree. See the corresponding README for more details.
+| Folder     | Contents                                         |
+|:-----------|:-------------------------------------------------|
+| `./bin`    | Scripts and data files for Ripple integrators.   |
+| `./Builds` | Platform-specific guides for building `rippled`. |
+| `./docs`   | Source documentation files and doxygen config.   |
+| `./cfg`    | Example configuration files.                     |
+| `./src`    | Source code.                                     |
 
-## For more information:
+Some of the directories under `src` are external repositories included using
+git-subtree. See those directories' README files for more details.
 
-* [Ripple Knowledge Center](https://ripple.com/learn/)
-* [Ripple Developer Center](https://ripple.com/build/)
-* Ripple Whitepapers & Reports
-  * [Ripple Consensus Whitepaper](https://ripple.com/files/ripple_consensus_whitepaper.pdf)
-  * [Ripple Solutions Guide](https://ripple.com/files/ripple_solutions_guide.pdf)
 
-To learn about how Ripple is transforming global payments visit
-[https://ripple.com/contact/](https://ripple.com/contact/)
+## Additional Documentation
 
-- - -
+* [XRP Ledger Dev Portal](https://xrpl.org/)
+* [Setup and Installation](https://xrpl.org/install-rippled.html)
+* [Source Documentation (Doxygen)](https://xrplf.github.io/rippled/)
 
-Copyright © 2017, Ripple Labs. All rights reserved.
+## See Also
 
-Portions of this document, including but not limited to the Ripple logo,
-images and image templates are the property of Ripple Labs and cannot be
-copied or used without permission.
+* [Clio API Server for the XRP Ledger](https://github.com/XRPLF/clio)
+* [Mailing List for Release Announcements](https://groups.google.com/g/ripple-server)
+* [Learn more about the XRP Ledger (YouTube)](https://www.youtube.com/playlist?list=PLJQ55Tj1hIVZtJ_JdTvSum2qMTsedWkNi)

SECURITY.md

@@ -0,0 +1,149 @@
+### Operating an XRP Ledger server securely
+
+For more details on operating an XRP Ledger server securely, please visit https://xrpl.org/manage-the-rippled-server.html.
+
+
+# Security Policy
+
+## Supported Versions
+
+Software constantly evolves. In order to focus resources, we only generally only accept vulnerability reports that affect recent and current versions of the software. We always accept reports for issues present in the **master**, **release** or **develop** branches, and with proposed, [open pull requests](https://github.com/ripple/rippled/pulls).
+
+## Identifying and Reporting Vulnerabilities
+
+We take security seriously and we do our best to ensure that all our releases are bug free. But we aren't perfect and sometimes things will slip through.
+
+### Responsible Investigation
+
+We urge you to examine our code carefully and responsibly, and to disclose any issues that you identify in a responsible fashion.
+
+Responsible investigation includes, but isn't limited to, the following:
+
+- Not performing tests on the main network. If testing is necessary, use the [Testnet or Devnet](https://xrpl.org/xrp-testnet-faucet.html).
+- Not targeting physical security measures, or attempting to use social engineering, spam, distributed denial of service (DDOS) attacks, etc.
+- Investigating bugs in a way that makes a reasonable, good faith effort not to be disruptive or harmful to the XRP Ledger and the broader ecosystem.
+
+### Responsible Disclosure
+
+If you discover a vulnerability or potential threat, or if you _think_
+you have, please reach out by dropping an email using the contact
+information below.
+
+Your report should include the following:
+
+- Your contact information (typically, an email address);
+- The description of the vulnerability;
+- The attack scenario (if any);
+- The steps to reproduce the vulnerability;
+- Any other relevant details or artifacts, including code, scripts or patches.
+
+In your email, please describe the issue or potential threat. If possible, include a "repro" (code that can reproduce the issue) or describe the best way to reproduce and replicate the issue. Please make your report as detailed and comprehensive as possible.
+
+For more information on responsible disclosure, please read this [Wikipedia article](https://en.wikipedia.org/wiki/Responsible_disclosure).
+
+## Report Handling Process
+
+Please report the bug directly to us and limit further disclosure. If you want to prove that you knew the bug as of a given time, consider using a cryptographic precommitment: hash the content of your report and publish the hash on a medium of your choice (e.g. on Twitter or as a memo in a transaction) as "proof" that you had written the text at a given point in time.
+
+Once we receive a report, we:
+
+1. Assign two people to independently evaluate the report;
+2. Consider their recommendations;
+3. If action is necessary, formulate a plan to address the issue;
+4. Communicate privately with the reporter to explain our plan.
+5. Prepare, test and release a version which fixes the issue; and
+6. Announce the vulnerability publicly.
+
+We will triage and respond to your disclosure within 24 hours. Beyond that, we will work to analyze the issue in more detail, formulate, develop and test a fix.
+
+While we commit to responding with 24 hours of your initial report with our triage assessment, we cannot guarantee a response time for the remaining steps. We will communicate with you throughout this process, letting you know where we are and keeping you updated on the timeframe.
+
+## Bug Bounty Program
+
+[Ripple](https://ripple.com) is generously sponsoring a bug bounty program for vulnerabilities in [`rippled`](https://github.com/XRPLF/rippled) (and other related projects, like [`xrpl.js`](https://github.com/XRPLF/xrpl.js), [`xrpl-py`](https://github.com/XRPLF/xrpl-py), [`xrpl4j`](https://github.com/XRPLF/xrpl4j)).
+
+This program allows us to recognize and reward individuals or groups that identify and report bugs. In summary, in order to qualify for a bounty, the bug must be:
+
+1. **In scope**. Only bugs in software under the scope of the program qualify. Currently, that means `rippled`, `xrpl.js`, `xrpl-py`, `xrpl4j`.
+2. **Relevant**. A security issue, posing a danger to user funds, privacy, or the operation of the XRP Ledger.
+3. **Original and previously unknown**. Bugs that are already known and discussed in public do not qualify. Previously reported bugs, even if publicly unknown, are not eligible.
+4. **Specific**. We welcome general security advice or recommendations, but we cannot pay bounties for that.
+5. **Fixable**. There has to be something we can do to permanently fix the problem. Note that bugs in other people’s software may still qualify in some cases. For example, if you find a bug in a library that we use which can compromise the security of software that is in scope and we can get it fixed, you may qualify for a bounty.
+6. **Unused**. If you use the exploit to attack the XRP Ledger, you do not qualify for a bounty. If you report a vulnerability used in an ongoing or past attack and there is specific, concrete evidence that suggests you are the attacker we reserve the right not to pay a bounty.
+
+The amount paid varies dramatically. Vulnerabilities that are harmless on their own, but could form part of a critical exploit will usually receive a bounty. Full-blown exploits can receive much higher bounties. Please don’t hold back partial vulnerabilities while trying to construct a full-blown exploit. We will pay a bounty to anyone who reports a complete chain of vulnerabilities even if they have reported each component of the exploit separately and those vulnerabilities have been fixed in the meantime. However, to qualify for a the full bounty, you must to have been the first to report each of the partial exploits.
+
+### Contacting Us
+
+To report a qualifying bug, please send a detailed report to:
+
+|Email Address|bugs@ripple.com                                      |
+|:-----------:|:----------------------------------------------------|
+|Short Key ID | `0xC57929BE`                                        |
+|Long Key ID  | `0xCD49A0AFC57929BE`                                |
+|Fingerprint  | `24E6 3B02 37E0 FA9C 5E96 8974 CD49 A0AF C579 29BE` |
+
+The full PGP key for this address, which is also available on several key servers (e.g. on [keys.gnupg.net](https://keys.gnupg.net)), is: 
+```
+-----BEGIN PGP PUBLIC KEY BLOCK-----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+=spg4
+-----END PGP PUBLIC KEY BLOCK-----
+```

appveyor.yml

@@ -1,94 +0,0 @@
-# Set environment variables.
-environment:
-
-  # We bundle up protoc.exe and only the parts of boost and openssl we need so
-  # that it's a small download. We also use appveyor's free cache, avoiding fees
-  # downloading from S3 each time.
-  # TODO: script to create this package.
-  RIPPLED_DEPS_PATH: rippled_deps17.01
-  RIPPLED_DEPS_URL: https://ripple.github.io/Downloads/appveyor/%RIPPLED_DEPS_PATH%.zip
-
-  # CMake honors these environment variables, setting the include/lib paths.
-  BOOST_ROOT: C:/%RIPPLED_DEPS_PATH%/boost
-  OPENSSL_ROOT: C:/%RIPPLED_DEPS_PATH%/openssl
-
-  # We've had trouble with AppVeyor apparently not having a stack as large
-  # as the *nix CI platforms.  AppVeyor support suggested that we try
-  # GCE VMs.  The following line is supposed to enable that VM type.
-  appveyor_build_worker_cloud: gce
-
-  matrix:
-  - build: cmake
-    target: msvc.debug
-    buildconfig: Debug
-
-os: Visual Studio 2017
-
-# At the end of each successful build we cache this directory.
-# https://www.appveyor.com/docs/build-cache/
-# Resulting archive should not exceed 100 MB.
-cache:
-  - 'C:\%RIPPLED_DEPS_PATH%'
-
-# This means we'll download a zip of the branch we want, rather than the full
-# history.
-shallow_clone: true
-
-install:
-  # We want  protoc.exe on PATH.
-  - SET PATH=C:/%RIPPLED_DEPS_PATH%;%PATH%
-
-  # Download dependencies if appveyor didn't restore them from the cache.
-  # Use 7zip to unzip.
-  - ps: |
-        if (-not(Test-Path 'C:/$env:RIPPLED_DEPS_PATH')) {
-            echo "Download from $env:RIPPLED_DEPS_URL"
-            Start-FileDownload "$env:RIPPLED_DEPS_URL"
-            7z x "$($env:RIPPLED_DEPS_PATH).zip" -oC:\ -y > $null
-            if ($LastExitCode -ne 0) { throw "7z failed" }
-        }
-
-  # Newer DEPS include a versions file.
-  # Dump it so we can verify correct behavior.
-  - ps: |
-        if (Test-Path "C:/$env:RIPPLED_DEPS_PATH/versions.txt") {
-          cat "C:/$env:RIPPLED_DEPS_PATH/versions.txt"
-        }
-
-# TODO: This is giving me grief
-# artifacts:
-#   # Save rippled.exe in the cloud after each build.
-#   - path: "build\\rippled.exe"
-
-build_script:
-  # We set the environment variables needed to put compilers on the PATH.
-  - '"%VS140COMNTOOLS%../../VC/vcvarsall.bat" x86_amd64'
-  # Show which version of the compiler we are using.
-  - cl
-  - ps: |
-          # Build with cmake
-          cmake --version
-          $cmake_target="$($env:target).ci"
-          "$cmake_target"
-          New-Item -ItemType Directory -Force -Path "build/$cmake_target"
-          Push-Location "build/$cmake_target"
-          cmake -G"Visual Studio 15 2017 Win64" -Dtarget="$cmake_target" ../..
-          if ($LastExitCode -ne 0) { throw "CMake failed" }
-          cmake --build . --config $env:buildconfig -- -m
-          if ($LastExitCode -ne 0) { throw "CMake build failed" }
-          Pop-Location
-
-after_build:
-  - ps: |
-        $exe="build/$cmake_target/$env:buildconfig/rippled"
-        "Exe is at $exe"
-
-test_script:
-  - ps: |
-        & {
-          # Run the rippled unit tests
-          & $exe --unittest --unittest-log
-          # https://connect.microsoft.com/PowerShell/feedback/details/751703/option-to-stop-script-if-command-line-exe-fails
-          if ($LastExitCode -ne 0) { throw "Unit tests failed" }
-        }
-

bin/ci/ubuntu/build-and-test.sh

@@ -1,162 +0,0 @@
-#!/bin/bash -u
-# We use set -e and bash with -u to bail on first non zero exit code of any
-# processes launched or upon any unbound variable.
-# We use set -x to print commands before running them to help with
-# debugging.
-set -ex
-__dirname=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
-echo "using CC: $CC"
-"${CC}" --version
-COMPNAME=$(basename $CC)
-echo "using CXX: ${CXX:-notset}"
-if [[ $CXX ]]; then
-  "${CXX}" --version
-fi
-echo "using TARGET: $TARGET"
-
-# Ensure APP defaults to rippled if it's not set.
-: ${APP:=rippled}
-echo "using APP: $APP"
-
-JOBS=${NUM_PROCESSORS:-2}
-if [[ ${TRAVIS:-false} != "true" ]]; then
-  JOBS=$((JOBS+1))
-fi
-
-if [ -x /usr/bin/time ] ; then
-  : ${TIME:="Duration: %E"}
-  export TIME
-  time=/usr/bin/time
-else
-  time=
-fi
-
-echo "cmake building ${APP}"
-: ${CMAKE_EXTRA_ARGS:=""}
-if [[ ${NINJA_BUILD:-} == true ]]; then
-  CMAKE_EXTRA_ARGS+=" -G Ninja"
-fi
-CMAKE_TARGET=${COMPNAME}.${TARGET}
-if [[ ${CI:-} == true ]]; then
-  CMAKE_TARGET=$CMAKE_TARGET.ci
-fi
-#
-# allow explicit setting of the name of the build
-# dir, otherwise default to the CMAKE_TARGET value
-#
-: "${BUILD_DIR:=$CMAKE_TARGET}"
-BUILDARGS=" -j${JOBS}"
-if [[ ${VERBOSE_BUILD:-} == true ]]; then
-  CMAKE_EXTRA_ARGS+=" -DCMAKE_VERBOSE_MAKEFILE=ON"
-
-  # TODO: if we use a different generator, this
-  # option to build verbose would need to change:
-  if [[ ${NINJA_BUILD:-} == true ]]; then
-    BUILDARGS+=" -v"
-  else
-    BUILDARGS+=" verbose=1"
-  fi
-fi
-if [[ ${USE_CCACHE:-} == true ]]; then
-  echo "using ccache with basedir [${CCACHE_BASEDIR:-}]"
-  CMAKE_EXTRA_ARGS+=" -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache"
-fi
-if [ -d "build/${BUILD_DIR}" ]; then
-  rm -rf "build/${BUILD_DIR}"
-fi
-
-mkdir -p "build/${BUILD_DIR}"
-pushd "build/${BUILD_DIR}"
-$time cmake ../.. -Dtarget=$CMAKE_TARGET ${CMAKE_EXTRA_ARGS}
-if [[ ${TARGET} == "docs" ]]; then
-  $time cmake --build . --target docs -- $BUILDARGS
-  ## mimic the standard test output for docs build
-  ## to make controlling processes like jenkins happy
-  if [ -f html_doc/index.html ]; then
-      echo "1 case, 1 test total, 0 failures"
-  else
-      echo "1 case, 1 test total, 1 failures"
-  fi
-  exit
-else
-  $time cmake --build . -- $BUILDARGS
-  if [[ ${BUILD_BOTH:-} == true ]]; then
-    if [[ ${TARGET} == *.unity ]]; then
-      cmake --build . --target rippled_classic -- $BUILDARGS
-    else
-      cmake --build . --target rippled_unity -- $BUILDARGS
-    fi
-  fi
-fi
-popd
-export APP_PATH="$PWD/build/${BUILD_DIR}/${APP}"
-echo "using APP_PATH: $APP_PATH"
-
-
-# See what we've actually built
-ldd $APP_PATH
-
-if [[ ${APP} == "rippled" ]]; then
-  APP_ARGS+="--unittest --quiet --unittest-log"
-  # Only report on src/ripple files
-  export LCOV_FILES="*/src/ripple/*"
-  # Nothing to explicitly exclude
-  export LCOV_EXCLUDE_FILES="LCOV_NO_EXCLUDE"
-  if [[ $TARGET != "coverage" && ${PARALLEL_TESTS:-} == true ]]; then
-    APP_ARGS+=" --unittest-jobs ${JOBS}"
-  fi
-else
-  : ${APP_ARGS:=}
-  : ${LCOV_FILES:="*/src/*"}
-  # Don't exclude anything
-  : ${LCOV_EXCLUDE_FILES:="LCOV_NO_EXCLUDE"}
-fi
-
-if [[ $TARGET == "coverage" ]]; then
-  export PATH=$PATH:$LCOV_ROOT/usr/bin
-
-  # Create baseline coverage data file
-  lcov --no-external -c -i -d . -o baseline.info | grep -v "ignoring data for external file"
-fi
-
-if [[ ${SKIP_TESTS:-} == true ]]; then
-  echo "skipping tests for ${TARGET}"
-  exit
-fi
-
-if [[ $TARGET == debug* && -v GDB_ROOT && -x $GDB_ROOT/bin/gdb ]]; then
-  $GDB_ROOT/bin/gdb -v
-  # Execute unit tests under gdb, printing a call stack
-  # if we get a crash.
-  export APP_ARGS
-  $GDB_ROOT/bin/gdb -return-child-result -quiet -batch \
-                    -ex "set env MALLOC_CHECK_=3" \
-                    -ex "set print thread-events off" \
-                    -ex run \
-                    -ex "thread apply all backtrace full" \
-                    -ex "quit" \
-                    --args $APP_PATH $APP_ARGS
-else
-  $APP_PATH $APP_ARGS
-fi
-
-if [[ $TARGET == "coverage" ]]; then
-  # Create test coverage data file
-  lcov --no-external -c -d . -o tests.info | grep -v "ignoring data for external file"
-
-  # Combine baseline and test coverage data
-  lcov -a baseline.info -a tests.info -o lcov-all.info
-
-  # Included files
-  lcov -e "lcov-all.info" "${LCOV_FILES}" -o lcov.pre.info
-
-  # Excluded files
-  lcov --remove lcov.pre.info "${LCOV_EXCLUDE_FILES}" -o lcov.info
-
-  # Push the results (lcov.info) to codecov
-  codecov -X gcov # don't even try and look for .gcov files ;)
-
-  find . -name "*.gcda" | xargs rm -f
-fi
-
-

bin/ci/ubuntu/install-dependencies.sh

@@ -1,29 +0,0 @@
-#!/bin/bash -u
-# Exit if anything fails. Echo commands to aid debugging.
-set -ex
-
-# Target working dir - defaults to current dir.
-# Can be set from caller, or in the first parameter
-TWD=$( cd ${TWD:-${1:-${PWD:-$( pwd )}}}; pwd )
-echo "Target path is: $TWD"
-# Override gcc version to $GCC_VER.
-# Put an appropriate symlink at the front of the path.
-mkdir -pv $HOME/bin
-for g in gcc g++ gcov gcc-ar gcc-nm gcc-ranlib
-do
-  test -x $( type -p ${g}-$GCC_VER )
-  ln -sv $(type -p ${g}-$GCC_VER) $HOME/bin/${g}
-done
-
-# What versions are we ACTUALLY running?
-if [ -x $HOME/bin/g++ ]; then
-    $HOME/bin/g++ -v
-else
-    g++ -v
-fi
-
-pip install --user requests==2.13.0
-pip install --user https://github.com/codecov/codecov-python/archive/master.zip
-
-bash bin/sh/install-boost.sh
-

bin/getInfoRippled.sh

@@ -1,86 +0,0 @@
-#!/usr/bin/env bash
-
-rippled_exe=/opt/ripple/bin/rippled
-conf_file=/etc/opt/ripple/rippled.cfg
-
-while getopts ":e:c:" opt; do
-    case $opt in
-        e)
-            rippled_exe=${OPTARG}
-            ;;
-        c)
-            conf_file=${OPTARG}
-            ;;
-        \?)
-            echo "Invalid option: -$OPTARG"
-    esac
-done
-
-tmp_loc=$(mktemp -d --tmpdir ripple_info.XXXX)
-cd /tmp
-chmod 751 ripple_info.*
-cd ~
-echo ${tmp_loc}
-
-cleaned_conf=${tmp_loc}/cleaned_rippled_cfg.txt
-
-if [[ -f ${conf_file} ]]
-then
-    db=$(sed -r -e 's/\<s[a-zA-Z0-9]{28}\>/secretsecretsecretsecretmaybe/g' ${conf_file} |\
-            awk -v OUT_FILE=${cleaned_conf} '
-    BEGIN {skip=0; db_path="";print > OUT_FILE}
-    /^\[validation_seed\]/ {skip=1; next}
-    /^\[node_seed\]/ {skip=1; next}
-    /^\[validation_manifest\]/ {skip=1; next}
-    /^\[validator_token\]/ {skip=1; next}
-    /^\[.*\]/ {skip=0}
-    skip==1 {next}
-    save==1 {save=0;db_path=$0}
-    /^\[database_path\]/ {save=1}
-    {print >> OUT_FILE}
-    END {print db_path}
-    ')
-fi
-
-echo "database_path: ${db}"
-df ${db} > ${tmp_loc}/db_path_df.txt
-echo
-
-# Send output from this script to a log file
-## this captures any messages
-## or errors from the script itself
-
-log_file=${tmp_loc}/get_info.log
-exec 3>&1 1>>${log_file} 2>&1
-
-## Send all stdout files to /tmp
-
-if [[ -x ${rippled_exe} ]]
-then
-    pgrep rippled && \
-    ${rippled_exe} --conf ${conf_file} \
-    -- server_info                  > ${tmp_loc}/server_info.txt
-fi
-
-df -h                               > ${tmp_loc}/free_disk_space.txt
-cat /proc/meminfo                   > ${tmp_loc}/amount_mem.txt
-cat /proc/swaps                     > ${tmp_loc}/swap_space.txt
-ulimit -a                           > ${tmp_loc}/reported_current_limits.txt
-
-for dev_path in $(df | awk '$1 ~ /^\/dev\// {print $1}'); do
-    # strip numbers from end and remove '/dev/'
-    dev=$(basename ${dev_path%%[0-9]})
-    if [[ "$(cat /sys/block/${dev}/queue/rotational)" = 0 ]]
-    then
-        echo "${dev} : SSD" >> ${tmp_loc}/is_ssd.txt
-    else
-        echo "${dev} : NO SSD" >> ${tmp_loc}/is_ssd.txt
-    fi
-done
-
-pushd ${tmp_loc}
-tar -czvf info-package.tar.gz *.txt *.log
-popd
-
-echo "Use the following command on your local machine to download from your rippled instance: scp <remote_rippled_username>@<remote_host>:${tmp_loc}/info-package.tar.gz <path/to/local_machine/directory>"| tee /dev/fd/3
-

bin/getRippledInfo

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+
+# This script generates information about your rippled installation
+# and system. It can be used to help debug issues that you may face
+# in your installation. While this script endeavors to not display any 
+# sensitive information, it is recommended that you read the output
+# before sharing with any third parties.
+
+
+rippled_exe=/opt/ripple/bin/rippled
+conf_file=/etc/opt/ripple/rippled.cfg
+
+while getopts ":e:c:" opt; do
+    case $opt in
+        e)
+            rippled_exe=${OPTARG}
+            ;;
+        c)
+            conf_file=${OPTARG}
+            ;;
+        \?)
+            echo "Invalid option: -$OPTARG"
+            exit -1
+    esac
+done
+
+tmp_loc=$(mktemp -d --tmpdir ripple_info.XXXXX)
+chmod 751 ${tmp_loc}
+awk_prog=${tmp_loc}/cfg.awk
+summary_out=${tmp_loc}/rippled_info.md
+printf "# rippled report info\n\n> generated at %s\n" "$(date -R)" > ${summary_out}
+
+function log_section {
+    printf "\n## %s\n" "$*" >> ${summary_out}
+
+    while read -r l; do
+        echo "    $l" >> ${summary_out}
+    done </dev/stdin
+}
+
+function join_by {
+    local IFS="$1"; shift; echo "$*";
+}
+
+if [[ -f ${conf_file} ]] ; then
+    exclude=( ips ips_fixed node_seed validation_seed validator_token )
+    cleaned_conf=${tmp_loc}/cleaned_rippled_cfg.txt
+    cat << 'EOP' >> ${awk_prog}
+    BEGIN {FS="[[:space:]]*=[[:space:]]*"; skip=0; db_path=""; print > OUT_FILE; split(exl,exa,"|")}
+    /^#/ {next}
+    save==2 && /^[[:space:]]*$/ {next}
+    /^\[.+\]$/ {
+      section=tolower(gensub(/^\[[[:space:]]*([a-zA-Z_]+)[[:space:]]*\]$/, "\\1", "g"))
+      skip = 0
+      for (i in exa) {
+        if (section == exa[i])
+          skip = 1
+      }
+      if (section == "database_path")
+        save = 1
+    }
+    skip==1 {next}
+    save==2 {save=0; db_path=$0}
+    save==1 {save=2}
+    $1 ~ /password/ {$0=$1"=<redacted>"}
+    {print >> OUT_FILE}
+    END {print db_path}
+EOP
+
+    db=$(\
+        sed -r -e 's/\<s[[:alnum:]]{28}\>/<redactedsecret>/g;s/^[[:space:]]*//;s/[[:space:]]*$//' ${conf_file} |\
+        awk -v OUT_FILE=${cleaned_conf} -v exl="$(join_by '|' "${exclude[@]}")" -f ${awk_prog})
+    rm ${awk_prog}
+    cat ${cleaned_conf} | log_section "cleaned config file"
+    rm ${cleaned_conf}
+    echo "${db}"  | log_section "database path"
+    df ${db}      | log_section "df: database"
+fi
+
+# Send output from this script to a log file
+## this captures any messages
+## or errors from the script itself
+
+log_file=${tmp_loc}/get_info.log
+exec 3>&1 1>>${log_file} 2>&1
+
+## Send all stdout files to /tmp
+
+if [[ -x ${rippled_exe} ]] ; then
+    pgrep rippled && \
+    ${rippled_exe} --conf ${conf_file} \
+    -- server_info                  | log_section "server info"
+fi
+
+cat /proc/meminfo                   | log_section "meminfo"
+cat /proc/swaps                     | log_section "swap space"
+ulimit -a                           | log_section "ulimit"
+
+if command -v lshw >/dev/null 2>&1 ; then
+    lshw    2>/dev/null             | log_section "hardware info"
+else
+    lscpu                           >  ${tmp_loc}/hw_info.txt
+    hwinfo                          >> ${tmp_loc}/hw_info.txt
+    lspci                           >> ${tmp_loc}/hw_info.txt
+    lsblk                           >> ${tmp_loc}/hw_info.txt
+    cat ${tmp_loc}/hw_info.txt | log_section "hardware info"
+    rm ${tmp_loc}/hw_info.txt
+fi
+
+if command -v iostat >/dev/null 2>&1 ; then
+    iostat -t -d -x 2 6             | log_section "iostat"
+fi
+
+df -h                               | log_section "free disk space"
+drives=($(df | awk '$1 ~ /^\/dev\// {print $1}' | xargs -n 1 basename))
+block_devs=($(ls /sys/block/))
+for d in "${drives[@]}"; do
+    for dev in "${block_devs[@]}"; do
+        #echo "D: [$d], DEV: [$dev]"
+        if [[ $d =~ $dev ]]; then
+            # this file (if exists) has 0 for SSD and 1 for HDD
+            if [[ "$(cat /sys/block/${dev}/queue/rotational 2>/dev/null)" == 0 ]] ; then
+                echo "${d} : SSD" >> ${tmp_loc}/is_ssd.txt
+            else
+                echo "${d} : NO SSD" >> ${tmp_loc}/is_ssd.txt
+            fi
+        fi
+    done
+done
+
+if [[ -f ${tmp_loc}/is_ssd.txt ]] ; then
+    cat ${tmp_loc}/is_ssd.txt | log_section "SSD"
+    rm ${tmp_loc}/is_ssd.txt
+fi
+
+cat ${log_file} | log_section "script log"
+
+cat << MSG | tee /dev/fd/3
+####################################################
+  rippled info has been gathered. Please copy the
+  contents of ${summary_out}
+  to a github gist at https://gist.github.com/
+
+  PLEASE REVIEW THIS FILE FOR ANY SENSITIVE DATA
+  BEFORE POSTING! We have tried our best to omit
+  any sensitive information from this file, but you
+  should verify before posting.
+####################################################
+MSG
+

bin/git/setup-upstreams.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+
+if [[ $# -ne 1 || "$1" == "--help" || "$1" == "-h" ]]
+then
+  name=$( basename $0 )
+  cat <<- USAGE
+  Usage: $name <username>
+  
+  Where <username> is the Github username of the upstream repo. e.g. XRPLF
+USAGE
+  exit 0
+fi
+
+# Create upstream remotes based on origin
+shift
+user="$1"
+# Get the origin URL. Expect it be an SSH-style URL
+origin=$( git remote get-url origin )
+if [[ "${origin}" == "" ]]
+then
+  echo Invalid origin remote >&2
+  exit 1
+fi
+# echo "Origin: ${origin}"
+# Parse the origin
+ifs_orig="${IFS}"
+IFS=':' read remote originpath <<< "${origin}"
+# echo "Remote: ${remote}, Originpath: ${originpath}"
+IFS='@' read sshuser server <<< "${remote}"
+# echo "SSHUser: ${sshuser}, Server: ${server}"
+IFS='/' read originuser repo <<< "${originpath}"
+# echo "Originuser: ${originuser}, Repo: ${repo}"
+if [[ "${sshuser}" == "" || "${server}" == "" || "${originuser}" == ""
+  || "${repo}" == "" ]]
+then
+  echo "Can't parse origin URL: ${origin}" >&2
+  exit 1
+fi
+upstream="https://${server}/${user}/${repo}"
+upstreampush="${remote}:${user}/${repo}"
+upstreamgroup="upstream upstream-push"
+current=$( git remote get-url upstream 2>/dev/null )
+currentpush=$( git remote get-url upstream-push 2>/dev/null )
+currentgroup=$( git config remotes.upstreams )
+if [[ "${current}" == "${upstream}" ]]
+then
+  echo "Upstream already set up correctly. Skip"
+elif [[ -n "${current}" && "${current}" != "${upstream}" &&
+  "${current}" != "${upstreampush}" ]]
+then
+  echo "Upstream already set up as: ${current}. Skip"
+else
+  if [[ "${current}" == "${upstreampush}" ]]
+  then
+    echo "Upstream set to dangerous push URL. Update."
+    _run git remote rename upstream upstream-push || \
+    _run git remote remove upstream
+    currentpush=$( git remote get-url upstream-push 2>/dev/null )
+  fi
+  _run git remote add upstream "${upstream}"
+fi
+
+if [[ "${currentpush}" == "${upstreampush}" ]]
+then
+  echo "upstream-push already set up correctly. Skip"
+elif [[ -n "${currentpush}" && "${currentpush}" != "${upstreampush}" ]]
+then
+  echo "upstream-push already set up as: ${currentpush}. Skip"
+else
+  _run git remote add upstream-push "${upstreampush}"
+fi
+
+if [[ "${currentgroup}" == "${upstreamgroup}" ]]
+then
+  echo "Upstreams group already set up correctly. Skip"
+elif [[ -n "${currentgroup}" && "${currentgroup}" != "${upstreamgroup}" ]]
+then
+  echo "Upstreams group already set up as: ${currentgroup}. Skip"
+else
+  _run git config --add remotes.upstreams "${upstreamgroup}"
+fi
+
+_run git fetch --jobs=$(nproc) upstreams
+
+exit 0
+

bin/git/squash-branches.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+if [[ $# -lt 3 || "$1" == "--help" || "$1" = "-h" ]]
+then
+  name=$( basename $0 )
+  cat <<- USAGE
+  Usage: $name workbranch base/branch user/branch [user/branch [...]]
+  
+  * workbranch will be created locally from base/branch
+  * base/branch and user/branch may be specified as user:branch to allow
+    easy copying from Github PRs
+  * Remotes for each user must already be set up
+USAGE
+exit 0
+fi
+
+work="$1"
+shift
+
+branches=( $( echo "${@}" | sed "s/:/\//" ) )
+base="${branches[0]}"
+unset branches[0]
+
+set -e
+
+users=()
+for b in "${branches[@]}"
+do
+  users+=( $( echo $b | cut -d/ -f1 ) )
+done
+
+users=( $( printf '%s\n' "${users[@]}" | sort -u ) )
+
+git fetch --multiple upstreams "${users[@]}"
+git checkout -B "$work" --no-track "$base"
+
+for b in "${branches[@]}"
+do
+  git merge --squash "${b}"
+  git commit -S # Use the commit message provided on the PR
+done
+
+# Make sure the commits look right
+git log --show-signature "$base..HEAD"
+
+parts=( $( echo $base | sed "s/\// /" ) )
+repo="${parts[0]}"
+b="${parts[1]}"
+push=$repo
+if [[ "$push" == "upstream" ]]
+then
+  push="upstream-push"
+fi
+if [[ "$repo" == "upstream" ]]
+then
+  repo="upstreams"
+fi
+cat << PUSH
+
+-------------------------------------------------------------------
+This script will not push. Verify everything is correct, then push
+to your repo, and create a PR if necessary. Once the PR is approved,
+run:
+
+git push $push HEAD:$b
+git fetch $repo
+-------------------------------------------------------------------
+PUSH
+

bin/git/update-version.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+if [[ $# -ne 3 || "$1" == "--help" || "$1" = "-h" ]]
+then
+  name=$( basename $0 )
+  cat <<- USAGE
+  Usage: $name workbranch base/branch version
+
+  * workbranch will be created locally from base/branch. If it exists,
+    it will be reused, so make sure you don't overwrite any work.
+  * base/branch may be specified as user:branch to allow easy copying
+    from Github PRs.
+USAGE
+exit 0
+fi
+
+work="$1"
+shift
+
+base=$( echo "$1" | sed "s/:/\//" )
+shift
+
+version=$1
+shift
+
+set -e
+
+git fetch upstreams
+
+git checkout -B "${work}" --no-track "${base}"
+
+push=$( git rev-parse --abbrev-ref --symbolic-full-name '@{push}' \
+              2>/dev/null ) || true
+if [[ "${push}" != "" ]]
+then
+  echo "Warning: ${push} may already exist."
+fi
+
+build=$( find -name BuildInfo.cpp )
+sed 's/\(^.*versionString =\).*$/\1 "'${version}'"/' ${build} > version.cpp && \
+diff "${build}" version.cpp && exit 1 || \
+mv -vi version.cpp ${build}
+
+git diff
+
+git add ${build}
+
+git commit -S -m "Set version to ${version}"
+
+git log --oneline --first-parent ${base}^..
+
+cat << PUSH
+
+-------------------------------------------------------------------
+This script will not push. Verify everything is correct, then push
+to your repo, and create a PR as described in CONTRIBUTING.md.
+-------------------------------------------------------------------
+PUSH

bin/physical.sh

@@ -0,0 +1,218 @@
+#!/bin/bash
+
+set -o errexit
+
+marker_base=985c80fbc6131f3a8cedd0da7e8af98dfceb13c7
+marker_commit=${1:-${marker_base}}
+
+if [ $(git merge-base ${marker_commit} ${marker_base}) != ${marker_base} ]; then
+  echo "first marker commit not an ancestor: ${marker_commit}"
+  exit 1
+fi
+
+if [ $(git merge-base ${marker_commit} HEAD) != $(git rev-parse --verify ${marker_commit}) ]; then
+  echo "given marker commit not an ancestor: ${marker_commit}"
+  exit 1
+fi
+
+if [ -e Builds/CMake ]; then
+  echo move CMake
+  git mv Builds/CMake cmake
+  git add --update .
+  git commit -m 'Move CMake directory' --author 'Pretty Printer <cpp@ripple.com>'
+fi
+
+if [ -e src/ripple ]; then
+
+  echo move protocol buffers
+  mkdir -p include/xrpl
+  if [ -e src/ripple/proto ]; then
+    git mv src/ripple/proto include/xrpl
+  fi
+
+  extract_list() {
+    git show ${marker_commit}:Builds/CMake/RippledCore.cmake | \
+    awk "/END ${1}/ { p = 0 } p && /src\/ripple/; /BEGIN ${1}/ { p = 1 }" | \
+    sed -e 's#src/ripple/##' -e 's#[^a-z]\+$##'
+  }
+
+  move_files() {
+    oldroot="$1"; shift
+    newroot="$1"; shift
+    detail="$1"; shift
+    files=("$@")
+    for file in ${files[@]}; do
+      if [ ! -e ${oldroot}/${file} ]; then
+        continue
+      fi
+      dir=$(dirname ${file})
+      if [ $(basename ${dir}) == 'details' ]; then
+        dir=$(dirname ${dir})
+      fi
+      if [ $(basename ${dir}) == 'impl' ]; then
+        dir="$(dirname ${dir})/${detail}"
+      fi
+      mkdir -p ${newroot}/${dir}
+      git mv ${oldroot}/${file} ${newroot}/${dir}
+    done
+  }
+
+  echo move libxrpl headers
+  files=$(extract_list 'LIBXRPL HEADERS')
+  files+=(
+    basics/SlabAllocator.h
+
+    beast/asio/io_latency_probe.h
+    beast/container/aged_container.h
+    beast/container/aged_container_utility.h
+    beast/container/aged_map.h
+    beast/container/aged_multimap.h
+    beast/container/aged_multiset.h
+    beast/container/aged_set.h
+    beast/container/aged_unordered_map.h
+    beast/container/aged_unordered_multimap.h
+    beast/container/aged_unordered_multiset.h
+    beast/container/aged_unordered_set.h
+    beast/container/detail/aged_associative_container.h
+    beast/container/detail/aged_container_iterator.h
+    beast/container/detail/aged_ordered_container.h
+    beast/container/detail/aged_unordered_container.h
+    beast/container/detail/empty_base_optimization.h
+    beast/core/LockFreeStack.h
+    beast/insight/Collector.h
+    beast/insight/Counter.h
+    beast/insight/CounterImpl.h
+    beast/insight/Event.h
+    beast/insight/EventImpl.h
+    beast/insight/Gauge.h
+    beast/insight/GaugeImpl.h
+    beast/insight/Group.h
+    beast/insight/Groups.h
+    beast/insight/Hook.h
+    beast/insight/HookImpl.h
+    beast/insight/Insight.h
+    beast/insight/Meter.h
+    beast/insight/MeterImpl.h
+    beast/insight/NullCollector.h
+    beast/insight/StatsDCollector.h
+    beast/test/fail_counter.h
+    beast/test/fail_stream.h
+    beast/test/pipe_stream.h
+    beast/test/sig_wait.h
+    beast/test/string_iostream.h
+    beast/test/string_istream.h
+    beast/test/string_ostream.h
+    beast/test/test_allocator.h
+    beast/test/yield_to.h
+    beast/utility/hash_pair.h
+    beast/utility/maybe_const.h
+    beast/utility/temp_dir.h
+
+    # included by only json/impl/json_assert.h
+    json/json_errors.h
+
+    protocol/PayChan.h
+    protocol/RippleLedgerHash.h
+    protocol/messages.h
+    protocol/st.h
+  )
+  files+=(
+    basics/README.md
+    crypto/README.md
+    json/README.md
+    protocol/README.md
+    resource/README.md
+  )
+  move_files src/ripple include/xrpl detail ${files[@]}
+
+  echo move libxrpl sources
+  files=$(extract_list 'LIBXRPL SOURCES')
+  move_files src/ripple src/libxrpl "" ${files[@]}
+
+  echo check leftovers
+  dirs=$(cd include/xrpl; ls -d */)
+  dirs=$(cd src/ripple; ls -d ${dirs} 2>/dev/null || true)
+  files="$(cd src/ripple; find ${dirs} -type f)"
+  if [ -n "${files}" ]; then
+    echo "leftover files:"
+    echo ${files}
+    exit
+  fi
+
+  echo remove empty directories
+  empty_dirs="$(cd src/ripple; find ${dirs} -depth -type d)"
+  for dir in ${empty_dirs[@]}; do
+    if [ -e ${dir} ]; then
+      rmdir ${dir}
+    fi
+  done
+
+  echo move xrpld sources
+  files=$(
+    extract_list 'XRPLD SOURCES'
+    cd src/ripple
+    find * -regex '.*\.\(h\|ipp\|md\|pu\|uml\|png\)'
+  )
+  move_files src/ripple src/xrpld detail ${files[@]}
+
+  files="$(cd src/ripple; find . -type f)"
+  if [ -n "${files}" ]; then
+    echo "leftover files:"
+    echo ${files}
+    exit
+  fi
+
+fi
+
+rm -rf src/ripple
+
+echo rename .hpp to .h
+find include src -name '*.hpp' -exec bash -c 'f="{}"; git mv "${f}" "${f%hpp}h"' \;
+
+echo move PerfLog.h
+if [ -e include/xrpl/basics/PerfLog.h ]; then
+  git mv include/xrpl/basics/PerfLog.h src/xrpld/perflog
+fi
+
+# Make sure all protobuf includes have the correct prefix.
+protobuf_replace='s:^#include\s*["<].*org/xrpl\([^">]\+\)[">]:#include <xrpl/proto/org/xrpl\1>:'
+# Make sure first-party includes use angle brackets and .h extension.
+ripple_replace='s:include\s*["<]ripple/\(.*\)\.h\(pp\)\?[">]:include <ripple/\1.h>:'
+beast_replace='s:include\s*<beast/:include <xrpl/beast/:'
+# Rename impl directories to detail.
+impl_rename='s:\(<xrpl.*\)/impl\(/details\)\?/:\1/detail/:'
+
+echo rewrite includes in libxrpl
+find include/xrpl src/libxrpl -type f -exec sed -i \
+  -e "${protobuf_replace}" \
+  -e "${ripple_replace}" \
+  -e "${beast_replace}" \
+  -e 's:^#include <ripple/:#include <xrpl/:' \
+  -e "${impl_rename}" \
+  {} +
+
+echo rewrite includes in xrpld
+# # https://www.baeldung.com/linux/join-multiple-lines
+libxrpl_dirs="$(cd include/xrpl; ls -d1 */ | sed 's:/$::')"
+# libxrpl_dirs='a\nb\nc\n'
+readarray -t libxrpl_dirs <<< "${libxrpl_dirs}"
+# libxrpl_dirs=(a b c)
+libxrpl_dirs=$(printf -v txt '%s\\|' "${libxrpl_dirs[@]}"; echo "${txt%\\|}")
+# libxrpl_dirs='a\|b\|c'
+find src/xrpld src/test -type f -exec sed -i \
+  -e "${protobuf_replace}" \
+  -e "${ripple_replace}" \
+  -e "${beast_replace}" \
+  -e "s:^#include <ripple/basics/PerfLog.h>:#include <xrpld/perflog/PerfLog.h>:" \
+  -e "s:^#include <ripple/\(${libxrpl_dirs}\)/:#include <xrpl/\1/:" \
+  -e 's:^#include <ripple/:#include <xrpld/:' \
+  -e "${impl_rename}" \
+  {} +
+
+git commit -m 'Rearrange sources' --author 'Pretty Printer <cpp@ripple.com>'
+find include src -type f \( -name '*.cpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-10 -i {} +
+git add --update .
+git commit -m 'Rewrite includes' --author 'Pretty Printer <cpp@ripple.com>'
+./Builds/levelization/levelization.sh
+git add --update .
+git commit -m 'Recompute loops' --author 'Pretty Printer <cpp@ripple.com>'

bin/sh/install-boost.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-# Assumptions:
-# 1) BOOST_ROOT and BOOST_URL are already defined,
-# and contain valid values.
-# 2) The last namepart of BOOST_ROOT matches the
-# folder name internal to boost's .tar.gz
-# When testing you can force a boost build by clearing travis caches:
-# https://travis-ci.org/ripple/rippled/caches
-set -e
-
-if [ -x /usr/bin/time ] ; then
-  : ${TIME:="Duration: %E"}
-  export TIME
-  time=/usr/bin/time
-else
-  time=
-fi
-
-if [ ! -d "$BOOST_ROOT/lib" ]
-then
-  wget $BOOST_URL -O /tmp/boost.tar.gz
-  cd `dirname $BOOST_ROOT`
-  rm -fr ${BOOST_ROOT}
-  tar xzf /tmp/boost.tar.gz
-  cd $BOOST_ROOT && \
-    $time ./bootstrap.sh --prefix=$BOOST_ROOT && \
-    $time ./b2 -d1 define=_GLIBCXX_USE_CXX11_ABI=0 -j$((2*${NUM_PROCESSORS:-2})) &&\
-    $time ./b2 -d0 define=_GLIBCXX_USE_CXX11_ABI=0 install
-else
-  echo "Using cached boost at $BOOST_ROOT"
-fi
-

bin/sh/install-vcpkg.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+set -exu
+
+: ${TRAVIS_BUILD_DIR:=""}
+: ${VCPKG_DIR:=".vcpkg"}
+export VCPKG_ROOT=${VCPKG_DIR}
+: ${VCPKG_DEFAULT_TRIPLET:="x64-windows-static"}
+
+export VCPKG_DEFAULT_TRIPLET
+
+EXE="vcpkg"
+if [[ -z ${COMSPEC:-} ]]; then
+    EXE="${EXE}.exe"
+fi
+
+if [[ -d "${VCPKG_DIR}" && -x "${VCPKG_DIR}/${EXE}" && -d "${VCPKG_DIR}/installed" ]] ; then
+    echo "Using cached vcpkg at ${VCPKG_DIR}"
+    ${VCPKG_DIR}/${EXE} list
+else
+    if [[ -d "${VCPKG_DIR}" ]] ; then
+        rm -rf "${VCPKG_DIR}"
+    fi
+    git clone --branch 2021.04.30 https://github.com/Microsoft/vcpkg.git ${VCPKG_DIR}
+    pushd ${VCPKG_DIR}
+    BSARGS=()
+    if [[ "$(uname)" == "Darwin" ]] ; then
+        BSARGS+=(--allowAppleClang)
+    fi
+    if [[ -z ${COMSPEC:-} ]]; then
+        chmod +x ./bootstrap-vcpkg.sh
+        time ./bootstrap-vcpkg.sh "${BSARGS[@]}"
+    else
+        time ./bootstrap-vcpkg.bat
+    fi
+    popd
+fi
+
+# TODO: bring boost in this way as well ?
+# NOTE: can pin specific ports to a commit/version like this:
+#    git checkout <SOME COMMIT HASH> ports/boost
+if [ $# -eq 0 ]; then
+    echo "No extra packages specified..."
+    PKGS=()
+else
+    PKGS=( "$@" )
+fi
+for LIB in "${PKGS[@]}"; do
+    time ${VCPKG_DIR}/${EXE} --clean-after-build install ${LIB}
+done
+
+

bin/sh/setup-msvc.sh

@@ -0,0 +1,40 @@
+
+# NOTE: must be sourced from a shell so it can export vars
+
+cat << BATCH > ./getenv.bat
+CALL %*
+ENV
+BATCH
+
+while read line ; do
+  IFS='"' read x path arg <<<"${line}"
+  if [ -f "${path}" ] ; then
+    echo "FOUND: $path"
+    export VCINSTALLDIR=$(./getenv.bat "${path}" ${arg} | grep "^VCINSTALLDIR=" | sed -E "s/^VCINSTALLDIR=//g")
+    if [ "${VCINSTALLDIR}" != "" ] ; then
+      echo "USING ${VCINSTALLDIR}"
+      export LIB=$(./getenv.bat "${path}" ${arg} | grep "^LIB=" | sed -E "s/^LIB=//g")
+      export LIBPATH=$(./getenv.bat "${path}" ${arg} | grep "^LIBPATH=" | sed -E "s/^LIBPATH=//g")
+      export INCLUDE=$(./getenv.bat "${path}" ${arg} | grep "^INCLUDE=" | sed -E "s/^INCLUDE=//g")
+      ADDPATH=$(./getenv.bat "${path}" ${arg} | grep "^PATH=" | sed -E "s/^PATH=//g")
+      export PATH="${ADDPATH}:${PATH}"
+      break
+    fi
+  fi
+done <<EOL
+"C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Auxiliary/Build/vcvarsall.bat" x86_amd64
+"C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Auxiliary/Build/vcvarsall.bat" x86_amd64
+"C:/Program Files (x86)/Microsoft Visual Studio/2017/BuildTools/VC/Auxiliary/Build/vcvarsall.bat" x86_amd64
+"C:/Program Files (x86)/Microsoft Visual Studio/2017/Community/VC/Auxiliary/Build/vcvarsall.bat" x86_amd64
+"C:/Program Files (x86)/Microsoft Visual Studio 15.0/VC/vcvarsall.bat" amd64
+"C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/vcvarsall.bat" amd64
+"C:/Program Files (x86)/Microsoft Visual Studio 13.0/VC/vcvarsall.bat" amd64
+"C:/Program Files (x86)/Microsoft Visual Studio 12.0/VC/vcvarsall.bat" amd64
+EOL
+# TODO: update the list above as needed to support newer versions of msvc tools
+
+rm -f getenv.bat
+
+if [ "${VCINSTALLDIR}" = "" ] ; then
+  echo "No compatible visual studio found!"
+fi

bin/start_sync_stop.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python
+"""A script to test rippled in an infinite loop of start-sync-stop.
+
+- Requires Python 3.7+.
+- Can be stopped with SIGINT.
+- Has no dependencies outside the standard library.
+"""
+
+import sys
+
+assert sys.version_info.major == 3 and sys.version_info.minor >= 7
+
+import argparse
+import asyncio
+import configparser
+import contextlib
+import json
+import logging
+import os
+from pathlib import Path
+import platform
+import subprocess
+import time
+import urllib.error
+import urllib.request
+
+# Enable asynchronous subprocesses on Windows. The default changed in 3.8.
+# https://docs.python.org/3.7/library/asyncio-platforms.html#subprocess-support-on-windows
+if (platform.system() == 'Windows' and sys.version_info.major == 3
+        and sys.version_info.minor < 8):
+    asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+
+DEFAULT_EXE = 'rippled'
+DEFAULT_CONFIGURATION_FILE = 'rippled.cfg'
+# Number of seconds to wait before forcefully terminating.
+PATIENCE = 120
+# Number of contiguous seconds in a sync state to be considered synced.
+DEFAULT_SYNC_DURATION = 60
+# Number of seconds between polls of state.
+DEFAULT_POLL_INTERVAL = 5
+SYNC_STATES = ('full', 'validating', 'proposing')
+
+
+def read_config(config_file):
+    # strict = False: Allow duplicate keys, e.g. [rpc_startup].
+    # allow_no_value = True: Allow keys with no values. Generally, these
+    # instances use the "key" as the value, and the section name is the key,
+    # e.g. [debug_logfile].
+    # delimiters = ('='): Allow ':' as a character in Windows paths. Some of
+    # our "keys" are actually values, and we don't want to split them on ':'.
+    config = configparser.ConfigParser(
+        strict=False,
+        allow_no_value=True,
+        delimiters=('='),
+    )
+    config.read(config_file)
+    return config
+
+
+def to_list(value, separator=','):
+    """Parse a list from a delimited string value."""
+    return [s.strip() for s in value.split(separator) if s]
+
+
+def find_log_file(config_file):
+    """Try to figure out what log file the user has chosen. Raises all kinds
+    of exceptions if there is any possibility of ambiguity."""
+    config = read_config(config_file)
+    values = list(config['debug_logfile'].keys())
+    if len(values) < 1:
+        raise ValueError(
+            f'no [debug_logfile] in configuration file: {config_file}')
+    if len(values) > 1:
+        raise ValueError(
+            f'too many [debug_logfile] in configuration file: {config_file}')
+    return values[0]
+
+
+def find_http_port(config_file):
+    config = read_config(config_file)
+    names = list(config['server'].keys())
+    for name in names:
+        server = config[name]
+        if 'http' in to_list(server.get('protocol', '')):
+            return int(server['port'])
+    raise ValueError(f'no server in [server] for "http" protocol')
+
+
+@contextlib.asynccontextmanager
+async def rippled(exe=DEFAULT_EXE, config_file=DEFAULT_CONFIGURATION_FILE):
+    """A context manager for a rippled process."""
+    # Start the server.
+    process = await asyncio.create_subprocess_exec(
+        str(exe),
+        '--conf',
+        str(config_file),
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    logging.info(f'rippled started with pid {process.pid}')
+    try:
+        yield process
+    finally:
+        # Ask it to stop.
+        logging.info(f'asking rippled (pid: {process.pid}) to stop')
+        start = time.time()
+        process.terminate()
+
+        # Wait nicely.
+        try:
+            await asyncio.wait_for(process.wait(), PATIENCE)
+        except asyncio.TimeoutError:
+            # Ask the operating system to kill it.
+            logging.warning(f'killing rippled ({process.pid})')
+            try:
+                process.kill()
+            except ProcessLookupError:
+                pass
+
+        code = await process.wait()
+        end = time.time()
+        logging.info(
+            f'rippled stopped after {end - start:.1f} seconds with code {code}'
+        )
+
+
+async def sync(
+        port,
+        *,
+        duration=DEFAULT_SYNC_DURATION,
+        interval=DEFAULT_POLL_INTERVAL,
+):
+    """Poll rippled on an interval until it has been synced for a duration."""
+    start = time.perf_counter()
+    while (time.perf_counter() - start) < duration:
+        await asyncio.sleep(interval)
+
+        request = urllib.request.Request(
+            f'http://127.0.0.1:{port}',
+            data=json.dumps({
+                'method': 'server_state'
+            }).encode(),
+            headers={'Content-Type': 'application/json'},
+        )
+        with urllib.request.urlopen(request) as response:
+            try:
+                body = json.loads(response.read())
+            except urllib.error.HTTPError as cause:
+                logging.warning(f'server_state returned not JSON: {cause}')
+                start = time.perf_counter()
+                continue
+
+        try:
+            state = body['result']['state']['server_state']
+        except KeyError as cause:
+            logging.warning(f'server_state response missing key: {cause.key}')
+            start = time.perf_counter()
+            continue
+        logging.info(f'server_state: {state}')
+        if state not in SYNC_STATES:
+            # Require a contiguous sync state.
+            start = time.perf_counter()
+
+
+async def loop(test,
+               *,
+               exe=DEFAULT_EXE,
+               config_file=DEFAULT_CONFIGURATION_FILE):
+    """
+    Start-test-stop rippled in an infinite loop.
+
+    Moves log to a different file after each iteration.
+    """
+    log_file = find_log_file(config_file)
+    id = 0
+    while True:
+        logging.info(f'iteration: {id}')
+        async with rippled(exe, config_file) as process:
+            start = time.perf_counter()
+            exited = asyncio.create_task(process.wait())
+            tested = asyncio.create_task(test())
+            # Try to sync as long as the process is running.
+            done, pending = await asyncio.wait(
+                {exited, tested},
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            if done == {exited}:
+                code = exited.result()
+                logging.warning(
+                    f'server halted for unknown reason with code {code}')
+            else:
+                assert done == {tested}
+                assert tested.exception() is None
+            end = time.perf_counter()
+            logging.info(f'synced after {end - start:.0f} seconds')
+        os.replace(log_file, f'debug.{id}.log')
+        id += 1
+
+
+logging.basicConfig(
+    format='%(asctime)s %(levelname)-8s %(message)s',
+    level=logging.INFO,
+    datefmt='%Y-%m-%d %H:%M:%S',
+)
+
+parser = argparse.ArgumentParser(
+    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+parser.add_argument(
+    'rippled',
+    type=Path,
+    nargs='?',
+    default=DEFAULT_EXE,
+    help='Path to rippled.',
+)
+parser.add_argument(
+    '--conf',
+    type=Path,
+    default=DEFAULT_CONFIGURATION_FILE,
+    help='Path to configuration file.',
+)
+parser.add_argument(
+    '--duration',
+    type=int,
+    default=DEFAULT_SYNC_DURATION,
+    help='Number of contiguous seconds required in a synchronized state.',
+)
+parser.add_argument(
+    '--interval',
+    type=int,
+    default=DEFAULT_POLL_INTERVAL,
+    help='Number of seconds to wait between polls of state.',
+)
+args = parser.parse_args()
+
+port = find_http_port(args.conf)
+
+
+def test():
+    return sync(port, duration=args.duration, interval=args.interval)
+
+
+try:
+    asyncio.run(loop(test, exe=args.rippled, config_file=args.conf))
+except KeyboardInterrupt:
+    # Squelch the message. This is a normal mode of exit.
+    pass

cfg/rippled-example.cfg

@@ -1,6 +1,5 @@
 #-------------------------------------------------------------------------------
 #
-# Rippled Server Instance Configuration Example
 #
 #-------------------------------------------------------------------------------
 #
@@ -14,13 +13,17 @@
 #
 #   4. HTTPS Client
 #
-#   5. Database
+#   5. <vacated>
 #
-#   6. Diagnostics
+#   6. Database
 #
-#   7. Voting
+#   7. Diagnostics
 #
-#   8. Example Settings
+#   8. Voting
+#
+#   9. Misc Settings
+#
+#  10. Example Settings
 #
 #-------------------------------------------------------------------------------
 #
@@ -32,14 +35,13 @@
 #
 #     rippled.cfg
 #
-#   For more information on where the rippled server instance searches for
-#   the file please visit the Ripple wiki. Specifically, the section explaining
-#   the --conf command line option:
+#   For more information on where the rippled server instance searches for the
+#   file, visit:
 #
-#     https://ripple.com/wiki/Rippled#--conf.3Dpath
+#     https://xrpl.org/commandline-usage.html#generic-options
 #
-#   This file should be named rippled.cfg.  This file is UTF-8 with Dos, UNIX,
-#   or Mac style end of lines.  Blank lines and lines beginning with '#' are
+#   This file should be named rippled.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.
 #
 # Notation
@@ -47,8 +49,8 @@
 #   In this document a simple BNF notation is used. Angle brackets denote
 #   required elements, square brackets denote optional elements, and single
 #   quotes indicate string literals. A vertical bar separating 1 or more
-#   elements is a logical "or"; Any one of the elements may be chosen.
-#   Parenthesis are notational only, and used to group elements, they are not
+#   elements is a logical "or"; any one of the elements may be chosen.
+#   Parentheses are notational only, and used to group elements; they are not
 #   part of the syntax unless they appear in quotes. White space may always
 #   appear between elements, it has no effect on values.
 #
@@ -124,13 +126,13 @@
 #       port = 80
 #
 #       [port_public]
-#       ip=0.0.0.0
+#       ip = 0.0.0.0
 #       port = 443
-#       protocol=peer,https
+#       protocol = peer,https
 #
 #       [port_private]
-#       ip=127.0.0.1
-#       protocol=http
+#       ip = 127.0.0.1
+#       protocol = http
 #
 #   When rippled is used as a command line client (for example, issuing a
 #   server stop command), the first port advertising the http or https
@@ -146,7 +148,11 @@
 #   ip = <IP-address>
 #
 #       Required. Determines the IP address of the network interface to bind
-#       to. To bind to all available interfaces, uses 0.0.0.0
+#       to. To bind to all available IPv4 interfaces, use 0.0.0.0
+#       To binding to all IPv4 and IPv6 interfaces, use ::
+#
+#       NOTE    if the ip value is ::, then any incoming IPv4 connections will
+#               be made as mapped IPv4 addresses.
 #
 #   port = <number>
 #
@@ -194,15 +200,31 @@
 #
 #   admin = [ IP, IP, IP, ... ]
 #
-#       A comma-separated list of IP addresses.
+#       A comma-separated list of IP addresses or subnets. Subnets
+#       should be represented in "slash" notation, such as:
+#         10.0.0.0/8
+#         172.16.0.0/12
+#         192.168.0.0/16
+#       Those examples are ipv4, but ipv6 is also supported.
+#       When configuring subnets, the address must match the
+#       underlying network address. Otherwise, the desired IP range is
+#       ambiguous. For example, 10.1.2.3/24 has a network address of
+#       10.1.2.0. Therefore, that subnet should be configured as
+#       10.1.2.0/24.
 #
-#       When set, grants administrative command access to the specified IP
+#       When set, grants administrative command access to the specified
 #       addresses. These commands may be issued over http, https, ws, or wss
-#       if configured on the port. If unspecified, the default is to not allow
+#       if configured on the port. If not provided, the default is to not allow
 #       administrative commands.
 #
+#       NOTE    A common configuration value for the admin field is "localhost".
+#               If you are listening on all IPv4/IPv6 addresses by specifing
+#               ip = :: then you can use admin = ::ffff:127.0.0.1,::1 to allow
+#               administrative access from both IPv4 and IPv6 localhost
+#               connections.
+#
 #       *SECURITY WARNING*
-#       0.0.0.0 may be specified to allow access from any IP address. It must
+#       0.0.0.0 or :: may be used to allow access from any IP address. It must
 #       be the only address specified and cannot be combined with other IPs.
 #       Use of this address can compromise server security, please consider its
 #       use carefully.
@@ -221,9 +243,10 @@
 #
 #   secure_gateway = [ IP, IP, IP, ... ]
 #
-#       A comma-separated list of IP addresses.
+#       A comma-separated list of IP addresses or subnets. See the
+#       details for the "admin" option above.
 #
-#       When set, allows the specified IP addresses to pass HTTP headers
+#       When set, allows the specified addresses to pass HTTP headers
 #       containing username and remote IP address for each session. If a
 #       non-empty username is passed in this way, then resource controls
 #       such as often resulting in "tooBusy" errors will be lifted. However,
@@ -238,9 +261,9 @@
 #       proxies. Since rippled 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
-#       message to the console shortly after startup
+#       If some IP addresses are included for both "admin" and
+#       "secure_gateway" connections, then they will be treated as
+#       "admin" addresses.
 #
 #   ssl_key = <filename>
 #   ssl_cert = <filename>
@@ -260,12 +283,14 @@
 #       ssl_cert
 #
 #           Specifies the path to the SSL certificate file in PEM format.
-#           This is not needed if the chain includes it.
+#           This is not needed if the chain includes it. Use ssl_chain if
+#           your certificate includes one or more intermediates.
 #
 #       ssl_chain
 #
 #           If you need a certificate chain, specify the path to the
 #           certificate chain here. The chain may include the end certificate.
+#           This must be used if the certificate includes intermediates.
 #
 #   ssl_ciphers = <cipherlist>
 #
@@ -280,7 +305,7 @@
 #               keep rippled from connecting to other instances of rippled or
 #               prevent RPC and WebSocket clients from connecting.
 #
-#   send_queue_limit = = [1..65535]
+#   send_queue_limit = [1..65535]
 #
 #       A Websocket will disconnect when its send queue exceeds this limit.
 #       The default is 100. A larger value may help with erratic disconnects but
@@ -341,6 +366,14 @@
 #   connection is no longer available.
 #
 #
+# [server_domain]
+#
+#   domain name
+#
+#   The domain under which a TOML file applicable to this server can be
+#   found. A server may lie about its domain so the TOML should contain
+#   a reference to this server by pubkey in the [nodes] array.
+#
 #
 #-------------------------------------------------------------------------------
 #
@@ -356,28 +389,46 @@
 #
 #
 #
+# [compression]
+#
+#   true or false
+#
+#   true - enables compression
+#   false - disables compression [default].
+#
+#   The rippled server can save bandwidth by compressing its peer-to-peer communications, 
+#   at a cost of greater CPU usage. If you enable link compression, 
+#   the server automatically compresses communications with peer servers
+#   that also have link compression enabled.
+#   https://xrpl.org/enable-link-compression.html
+#
+#
+#
 # [ips]
 #
-#   List of hostnames or ips where the Ripple protocol is served.  For a starter
-#   list, you can either copy entries from: https://ripple.com/ripple.txt or if
-#   you prefer you can specify r.ripple.com 51235
+#   List of hostnames or ips where the Ripple protocol is served.  A default
+#   starter list is included in the code and used if no other hostnames are
+#   available.
 #
-#   One IPv4 address or domain names per line is allowed. A port may must be
-#   specified after adding a space to the address.  By convention, if known,
-#   IPs are listed in from most to least trusted.
+#   One address or domain name per line is allowed. A port may be specified
+#   after adding a space to the address. If a port is not specified, the default
+#   port of 2459 will be used. Many servers still use the legacy port of 51235.
+#   To connect to such servers, you must specify the port number. The ordering
+#   of entries does not generally matter.
+#
+#   The default list of entries is:
+#     - r.ripple.com 51235
+#     - sahyadri.isrdc.in 51235
+#     - hubs.xrpkuwait.com 51235
+#     - hub.xrpl-commons.org 51235
 #
 #   Examples:
-#    192.168.0.1
-#    192.168.0.1 3939
-#    r.ripple.com 51235
-#
-#   This will give you a good, up-to-date list of addresses:
 #
 #   [ips]
+#   192.168.0.1
+#   192.168.0.1 2459
 #   r.ripple.com 51235
 #
-#   The default is: [ips_fixed] addresses (if present) or r.ripple.com 51235
-#
 #
 # [ips_fixed]
 #
@@ -387,8 +438,8 @@
 #   Ripple network through a public-facing server, or for building a set
 #   of cluster peers.
 #
-#   One IPv4 address or domain names per line is allowed. A port must be
-#   specified after adding a space to the address.
+#   One address or domain names per line is allowed. A port must be specified
+#   after adding a space to the address.
 #
 #
 #
@@ -430,17 +481,11 @@
 #
 #
 #
-# [sntp_servers]
+# [max_transactions]
 #
-#   IP address or domain of NTP servers to use for time synchronization.
-#
-#   These NTP servers are suitable for rippled servers located in the United
-#   States:
-#      time.windows.com
-#      time.apple.com
-#      time.nist.gov
-#      pool.ntp.org
+#   Configure the maximum number of transactions to have in the job queue
 #
+#   Must be a number between 100 and 1000, defaults to 250
 #
 #
 # [overlay]
@@ -464,6 +509,23 @@
 #       single host from consuming all inbound slots. If the value is not
 #       present the server will autoconfigure an appropriate limit.
 #
+#   max_unknown_time = <number>
+#
+#       The maximum amount of time, in seconds, that an outbound connection
+#       is allowed to stay in the "unknown" tracking state. This option can
+#       take any value between 300 and 1800 seconds, inclusive. If the option
+#       is not present the server will autoconfigure an appropriate limit.
+#
+#       The current default (which is subject to change) is 600 seconds.
+#
+#   max_diverged_time = <number>
+#
+#       The maximum amount of time, in seconds, that an outbound connection
+#       is allowed to stay in the "diverged" tracking state. The option can
+#       take any value between 60 and 900 seconds, inclusive. If the option
+#       is not present the server will autoconfigure an appropriate limit.
+#
+#       The current default (which is subject to change) is 300 seconds.
 #
 #
 # [transaction_queue] EXPERIMENTAL
@@ -496,14 +558,6 @@
 #       than the original transaction's fee, or meet the current open
 #       ledger fee to be considered. Default: 25.
 #
-#   multi_txn_percent = <number>
-#
-#       If a client submits multiple transactions (different sequence
-#       numbers), later transactions must pay a fee at least <number>
-#       percent higher than the transaction with the previous sequence
-#       number.
-#       Default: -90.
-#
 #   minimum_escalation_multiplier = <number>
 #
 #       At ledger close time, the median fee level of the transactions
@@ -538,6 +592,20 @@
 #       into the ledger at the minimum required fee before the required
 #       fee escalates. Default: no maximum.
 #
+#   normal_consensus_increase_percent = <number>
+#
+#       (Optional) When the ledger has more transactions than "expected",
+#       and performance is humming along nicely, the expected ledger size
+#       is updated to the previous ledger size plus this percentage.
+#       Default: 20
+#
+#   slow_consensus_decrease_percent = <number>
+#
+#       (Optional) When consensus takes longer than appropriate, the
+#       expected ledger size is updated to the minimum of the previous
+#       ledger size or the "expected" ledger size minus this percentage.
+#       Default: 50
+#
 #   maximum_txn_per_account = <number>
 #
 #       Maximum number of transactions that one account can have in the
@@ -559,22 +627,43 @@
 #
 #-------------------------------------------------------------------------------
 #
-# 3. Ripple Protocol
+# 3. Protocol
 #
 #-------------------
 #
 #   These settings affect the behavior of the server instance with respect
-#   to Ripple payment protocol level activities such as validating and
-#   closing ledgers or adjusting fees in response to server overloads.
+#   to protocol level activities such as validating and closing ledgers
+#   adjusting fees in response to server overloads.
 #
 #
 #
-# [node_size]
 #
-#   Tunes the servers based on the expected load and available memory. Legal
-#   sizes are "tiny", "small", "medium", "large", and "huge". We recommend
-#   you start at the default and raise the setting if you have extra memory.
-#   The default is "tiny".
+# [relay_proposals]
+#
+#   Controls the relay and processing behavior for proposals received by this
+#   server that are issued by validators that are not on the server's UNL.
+#
+#   Legal values are:
+#     "all"            - Relay and process all incoming proposals
+#     "trusted"        - Relay only trusted proposals, but locally process all
+#     "drop_untrusted" - Relay only trusted proposals, do not process untrusted
+#
+#   The default is "trusted".
+#
+#
+# [relay_validations]
+#
+#   Controls the relay and processing behavior for validations received by this
+#   server that are issued by validators that are not on the server's UNL.
+#
+#   Legal values are:
+#     "all"            - Relay and process all incoming validations
+#     "trusted"        - Relay only trusted validations, but locally process all
+#     "drop_untrusted" - Relay only trusted validations, do not process untrusted
+#
+#   The default is "all".
+#
+#
 #
 #
 #
@@ -676,7 +765,9 @@
 #   When searching for paths, the default search aggressiveness. This can take
 #   exponentially more resources as the size is increased.
 #
-#   The default is: 7
+#   The recommended value to support advanced pathfinding is: 7
+#
+#   The default is: 2
 #
 # [path_search_fast]
 # [path_search_max]
@@ -685,12 +776,19 @@
 #   If you do not need pathfinding, you can set path_search_max to zero to
 #   disable it and avoid some expensive bookkeeping.
 #
-#   The default for 'path_search_fast' is 2. The default for 'path_search_max' is 10.
+#   To support advanced pathfinding the recommended value for
+#   'path_search_fast' is 2, and for 'path_search_max' is 10.
+#
+#   The default for 'path_search_fast' is 2. The default for 'path_search_max' is 3.
 #
 # [path_search_old]
 #
 #   For clients that use the legacy path finding interfaces, the search
-#   aggressiveness to use. The default is 7.
+#   aggressiveness to use.
+#
+#   The recommended value to support advanced pathfinding is: 7.
+#
+#   The default is: 2
 #
 #
 #
@@ -704,10 +802,48 @@
 # [workers]
 #
 #   Configures the number of threads for processing work submitted by peers
-#   and clients. If not specified, then the value is automatically determined
-#   by factors including the number of system processors and whether this
-#   node is a validator.
+#   and clients. If not specified, then the value is automatically set to the
+#   number of processor threads plus 2 for networked nodes. Nodes running in
+#   stand alone mode default to 1 worker.
 #
+# [io_workers]
+#
+#   Configures the number of threads for processing raw inbound and outbound IO.
+#
+# [prefetch_workers]
+#
+#   Configures the number of threads for performing nodestore prefetching.
+#
+#
+#
+# [network_id]
+#
+#   Specify the network which this server is configured to connect to and
+#   track. If set, the server will not establish connections with servers
+#   that are explicitly configured to track another network.
+#
+#   Network identifiers are usually unsigned integers in the range 0 to
+#   4294967295 inclusive. The server also maps the following well-known
+#   names to the corresponding numerical identifier:
+#
+#   main    -> 0
+#   testnet -> 1
+#   devnet  -> 2
+#
+#   If this value is not specified the server is not explicitly configured
+#   to track a particular network.
+#
+#
+# [ledger_replay]
+#
+#   0 or 1.
+#
+#   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
+#      the ledger header and the transactions instead of the whole ledger.
+#      And the ledger is built by applying the transactions to the parent
+#      ledger.
 #
 #-------------------------------------------------------------------------------
 #
@@ -749,11 +885,9 @@
 #   certificates that the server will accept for verifying HTTP servers.
 #   Used only for outbound HTTPS client connections.
 #
-#
-#
 #-------------------------------------------------------------------------------
 #
-# 5. Database
+# 6. Database
 #
 #------------
 #
@@ -800,33 +934,86 @@
 #       RocksDB is an alternative backend for systems that don't use solid-state
 #       drives.  Because RocksDB's performance degrades as it stores more data,
 #       keeping full history is not advised, and using online delete is
-#       recommended.  RocksDB is not available on Windows.
+#       recommended.
 #
-#       The RocksDB backend also provides these optional parameters:
+#   Required keys for NuDB and RocksDB:
 #
-#       compression         0 for none, 1 for Snappy compression
+#       path                Location to store the database
 #
+#   Optional keys
 #
+#       cache_size          Size of cache for database records. Default is 16384.
+#                           Setting this value to 0 will use the default value.
 #
-#   Required keys:
-#       path                Location to store the database (all types)
+#       cache_age           Length of time in minutes to keep database records
+#                           cached. Default is 5 minutes. Setting this value to
+#                           0 will use the default value.
 #
-#   Optional keys:
+#                           Note: if neither cache_size nor cache_age is
+#                           specified, the cache for database records will not
+#                           be created. If only one of cache_size or cache_age
+#                           is specified, the cache will be created using the
+#                           default value for the unspecified parameter.
 #
-#       These keys are possible for any type of backend:
+#                           Note: the cache will not be created if online_delete
+#                           is specified.
+#
+#       fast_load           Boolean. If set, load the last persisted ledger
+#                           from disk upon process start before syncing to
+#                           the network. This is likely to improve performance
+#                           if sufficient IOPS capacity is available.
+#                           Default 0.
+#
+#   Optional keys for NuDB or RocksDB:
+#
+#       earliest_seq        The default is 32570 to match the XRP ledger
+#                           network's earliest allowed sequence. Alternate
+#                           networks may set this value. Minimum value of 1.
 #
 #       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.
 #
-#       advisory_delete     0 for disabled, 1 for enabled. If set, then
-#                           require administrative RPC call "can_delete"
-#                           to enable online deletion of ledger records.
+#       These keys modify the behavior of online_delete, and thus are only
+#       relevant if online_delete is defined and non-zero:
 #
-#       earliest_seq        The default is 32570 to match the XRP ledger
-#                           network's earliest allowed sequence. Alternate
-#                           networks may set this value. Minimum value of 1. 
+#       advisory_delete     0 for disabled, 1 for enabled. If set, the
+#                           administrative RPC call "can_delete" is required
+#                           to enable online deletion of ledger records.
+#                           Online deletion does not run automatically if
+#                           non-zero and the last deletion was on a ledger
+#                           greater than the current "can_delete" setting.
+#                           Default is 0.
+#
+#       delete_batch        When automatically purging, SQLite database
+#                           records are deleted in batches. This value
+#                           controls the maximum size of each batch. Larger
+#                           batches keep the databases locked for more time,
+#                           which may cause other functions to fall behind,
+#                           and thus cause the node to lose sync.
+#                           Default is 100.
+#
+#       back_off_milliseconds
+#                           Number of milliseconds to wait between
+#                           online_delete batches to allow other functions
+#                           to catch up.
+#                           Default is 100.
+#
+#       age_threshold_seconds
+#                           The online delete process will only run if the
+#                           latest validated ledger is younger than this
+#                           number of seconds.
+#                           Default is 60.
+#
+#       recovery_wait_seconds
+#                           The online delete process checks periodically
+#                           that rippled 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 
+#                           checking until healthy.
+#                           Default is 5.
 #
 #   Notes:
 #       The 'node_db' entry configures the primary, persistent storage.
@@ -838,45 +1025,108 @@
 #   [import_db]     Settings for performing a one-time import (optional)
 #   [database_path]   Path to the book-keeping databases.
 #
-#   [shard_db]      Settings for the Shard Database (optional)
+#   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.
+#
+#   [sqlite]       Tuning settings for the SQLite databases (optional)
 #
 #   Format (without spaces):
 #       One or more lines of case-insensitive key / value pairs:
 #       <key> '=' <value>
 #       ...
 #
-#   Example:
-#       type=nudb
-#       path=db/nudb
+#   Example 1:
+#       safety_level=low
 #
-#   The "type" field must be present and controls the choice of backend:
+#   Example 2:
+#       journal_mode=off
+#       synchronous=off
 #
-#   type = NuDB
+#   WARNING: These settings can have significant effects on data integrity,
+#   particularly in systemic failure scenarios. It is strongly recommended
+#   that they be left at their defaults unless the server is having
+#   performance issues during normal operation or during automatic purging
+#   (online_delete) operations. A warning will be logged on startup if
+#   'ledger_history' is configured to store more than 10,000,000 ledgers and
+#   any of these settings are less safe than the default. This is due to the
+#   inordinate amount of time and bandwidth it will take to safely rebuild a
+#   corrupted database of that size from other peers.
 #
-#   type = RocksDB
+#   Optional keys:
 #
-#       The RocksDB backend also provides these optional parameters:
+#       safety_level        Valid values: high, low
+#                           The default is "high", which tunes the SQLite
+#                           databases in the most reliable mode, and is
+#                           equivalent to:
+#                             journal_mode=wal
+#                             synchronous=normal
+#                             temp_store=file
+#                           "low" is equivalent to:
+#                             journal_mode=memory
+#                             synchronous=off
+#                             temp_store=memory
+#                           These "low" settings trade speed and reduced I/O
+#                           for a higher risk of data loss. See the
+#                           individual settings below for more information.
+#                           This setting may not be combined with any of the
+#                           other tuning settings: "journal_mode",
+#                           "synchronous", or "temp_store".
 #
-#       compression         0 for none, 1 for Snappy compression
+#       journal_mode        Valid values: delete, truncate, persist, memory, wal, off
+#                           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
+#                           database is likely to be corrupted.
+#                           See https://www.sqlite.org/pragma.html#pragma_journal_mode
+#                           for more details about the available options.
+#                           This setting may not be combined with the
+#                           "safety_level" setting.
 #
-#   Required keys:
-#       path                Location to store the database (all types)
+#       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
+#                           passed to the OS, which can significantly
+#                           increase speed, but risks data corruption if
+#                           the host computer crashes before writing that
+#                           data to disk.
+#                           See https://www.sqlite.org/pragma.html#pragma_synchronous
+#                           for more details about the available options.
+#                           This setting may not be combined with the
+#                           "safety_level" setting.
 #
-#       max_size_gb         Maximum disk space the database will utilize (in gigabytes)
-#
-#
-#   There are 4 bookkeeping SQLite database that the server creates and
-#   maintains. If you omit this configuration setting, it will default to
-#   creating a directory called "db" located in the same place as your
-#   rippled.cfg file. Partial pathnames will be considered relative to
-#   the location of the rippled executable.
+#       temp_store          Valid values: default, file, memory
+#                           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,
+#                           of these temporary objects.
+#                           See https://www.sqlite.org/pragma.html#pragma_temp_store
+#                           for more details about the available options.
+#                           This setting may not be combined with the
+#                           "safety_level" setting.
 #
+#       page_size           Valid values: integer (MUST be power of 2 between 512 and 65536)
+#                           The default is 4096 bytes. This setting determines
+#                           the size of a page in the transaction.db file.
+#                           See https://www.sqlite.org/pragma.html#pragma_page_size 
+#                           for more details about the available options.
 #
+#       journal_size_limit  Valid values: integer
+#                           The default is 1582080. This setting limits
+#                           the size of the journal for transaction.db file. When the limit is
+#                           reached, older entries will be deleted.
+#                           See https://www.sqlite.org/pragma.html#pragma_journal_size_limit
+#                           for more details about the available options.
 #
 #
 #-------------------------------------------------------------------------------
 #
-# 6. Diagnostics
+# 7. Diagnostics
 #
 #---------------
 #
@@ -950,7 +1200,7 @@
 #
 #-------------------------------------------------------------------------------
 #
-# 7. Voting
+# 8. Voting
 #
 #----------
 #
@@ -985,7 +1235,7 @@
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           account_reserve = 20000000   # 20 XRP
+#           account_reserve = 10000000   # 10 XRP
 #
 #   owner_reserve = <drops>
 #
@@ -997,11 +1247,119 @@
 #       default. Don't change this without understanding the consequences.
 #
 #       Example:
-#           owner_reserve = 5000000      # 5 XRP
+#           owner_reserve = 2000000      # 2 XRP
 #
 #-------------------------------------------------------------------------------
 #
-# 8. Example Settings
+# 9. Misc Settings
+#
+#-----------------
+#
+# [node_size]
+#
+#   Tunes the servers based on the expected load and available memory. Legal
+#   sizes are "tiny", "small", "medium", "large", and "huge". We recommend
+#   you start at the default and raise the setting if you have extra memory.
+#
+#   The code attempts to automatically determine the appropriate size for
+#   this parameter based on the amount of RAM and the number of execution
+#   cores available to the server. The current decision matrix is:
+#
+#   |         |         Cores          |
+#   |---------|------------------------|
+#   |   RAM   |   1  | 2 or 3 |   ≥ 4  |
+#   |---------|------|--------|--------|
+#   |  < ~8GB | tiny |   tiny |   tiny |
+#   | < ~12GB | tiny |  small |  small |
+#   | < ~16GB | tiny |  small | medium |
+#   | < ~24GB | tiny |  small |  large |
+#   | < ~32GB | tiny |  small |   huge |
+#
+# [signing_support]
+#
+#   Specifies whether the server will accept "sign" and "sign_for" commands
+#   from remote users. Even if the commands are sent over a secure protocol
+#   like secure websocket, this should generally be discouraged, because it
+#   requires sending the secret to use for signing to the server. In order
+#   to sign transactions, users should prefer to use a standalone signing
+#   tool instead.
+#
+#   This flag has no effect on the "sign" and "sign_for" command line options
+#   that rippled makes available.
+#
+#   The default value of this field is "false"
+#
+#   Example:
+#
+#   [signing_support]
+#   true
+#
+# [crawl]
+#
+#   List of options to control what data is reported through the /crawl endpoint
+#   See https://xrpl.org/peer-crawler.html
+#
+#   <flag>
+#
+#       Enable or disable access to /crawl requests. Default is '1' which
+#       enables access.
+#
+#   overlay = <flag>
+#
+#       Report information about peers this server is connected to, similar
+#       to the "peers" RPC API. Default is '1' which means to report peer
+#       overlay info.
+#
+#   server = <flag>
+#
+#       Report information about the local server, similar to the "server_state"
+#       RPC API. Default is '1' which means to report local server info.
+#
+#   counts = <flag>
+#
+#       Report information about the local server health counters, similar to
+#       the "get_counts" RPC API. Default is '0' which means not to report
+#       server counts.
+#
+#   unl = <flag>
+#
+#       Report information about the local server's validator lists, similar to
+#       the "validators" and "validator_list_sites" RPC APIs. Default is '1'
+#       which means to report server validator lists.
+#
+#   Examples:
+#
+#   [crawl]
+#   0
+#
+#   [crawl]
+#   overlay = 1
+#   server = 1
+#   counts = 0
+#   unl = 1
+#
+# [vl]
+#
+#   Options to control what data is reported through the /vl endpoint
+#   See [...]
+#
+#   enable = <flag>
+#
+#       Enable or disable access to /vl requests. Default is '1' which
+#       enables access.
+#
+# [beta_rpc_api]
+#
+#   0 or 1.
+#
+#   0: Disable the beta API version for JSON-RPC and WebSocket [default]
+#   1: Enable the beta API version for testing. The beta API version
+#      contains breaking changes that require a new API version number.
+#      They are not ready for public consumption.
+#
+#-------------------------------------------------------------------------------
+#
+# 10. Example Settings
 #
 #--------------------
 #
@@ -1029,6 +1387,12 @@
 #       Admin level API commands over Secure Websockets, when originating
 #       from the same machine (via the loopback adapter at 127.0.0.1).
 #
+#   "grpc"
+#
+#       ETL commands for Clio. We recommend setting secure_gateway
+#       in this section to a comma-separated list of the addresses
+#       of your Clio servers, in order to bypass rippled's rate limiting.
+#
 #   This port is commented out but can be enabled by removing
 #   the '#' from each corresponding line including the entry under [server]
 #
@@ -1062,8 +1426,13 @@ admin = 127.0.0.1
 protocol = http
 
 [port_peer]
+# Many servers still use the legacy port of 51235, so for backward-compatibility
+# we maintain that port number here. However, for new servers we recommend
+# changing this to the default port of 2459.
 port = 51235
 ip = 0.0.0.0
+# alternatively, to accept connections on IPv4 + IPv6, use:
+#ip = ::
 protocol = peer
 
 [port_ws_admin_local]
@@ -1071,62 +1440,52 @@ port = 6006
 ip = 127.0.0.1
 admin = 127.0.0.1
 protocol = ws
+send_queue_limit = 500
+
+[port_grpc]
+port = 50051
+ip = 127.0.0.1
+secure_gateway = 127.0.0.1
 
 #[port_ws_public]
-#port = 5005
+#port = 6005
 #ip = 127.0.0.1
 #protocol = wss
+#send_queue_limit = 500
 
 #-------------------------------------------------------------------------------
 
-[node_size]
-medium
-
 # This is primary persistent datastore for rippled.  This includes transaction
 # metadata, account states, and ledger headers.  Helpful information can be
-# found here: https://ripple.com/wiki/NodeBackEnd
-# delete old ledgers while maintaining at least 2000. Do not require an
-# external administrative command to initiate deletion.
+# found at https://xrpl.org/capacity-planning.html#node-db-type
+# 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
+#    synced to the network.
+# online_delete=512 is recommended to delete old ledgers while maintaining at
+#    least 512.
+# advisory_delete=0 allows the online delete process to run automatically
+#    when the node has approximately two times the "online_delete" value of
+#    ledgers. No external administrative command is required to initiate
+#    deletion.
 [node_db]
-type=RocksDB
-path=/var/lib/rippled/db/rocksdb
-open_files=2000
-filter_bits=12
-cache_mb=256
-file_size_mb=8
-file_size_mult=2
-online_delete=2000
+type=NuDB
+path=/var/lib/rippled/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.
-# NuDB requires SSD storage. Helpful information can be found here
-# https://ripple.com/build/history-sharding
-#[shard_db]
-#type=NuDB
-#path=/var/lib/rippled/db/shards/nudb
-#max_size_gb=500
-
 [database_path]
 /var/lib/rippled/db
 
+
 # This needs to be an absolute directory reference, not a relative one.
 # Modify this value as required.
 [debug_logfile]
 /var/log/rippled/debug.log
 
-[sntp_servers]
-time.windows.com
-time.apple.com
-time.nist.gov
-pool.ntp.org
-
-# Where to find some other servers speaking the Ripple protocol.
-[ips]
-r.ripple.com 51235
-
-# To use the XRP test network (see https://ripple.com/build/xrp-test-net/),
-# use the following [ips] section instead:
+# To use the XRP test network
+# (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
+# use the following [ips] section:
 # [ips]
 # r.altnet.rippletest.net 51235
 

cfg/rippled-example.service

@@ -1,10 +0,0 @@
-[Unit]
-Description=Ripple Peer-to-Peer Network Daemon
- 
-[Service]
-Type=simple
-User=nobody
-ExecStart=/usr/bin/rippled --conf=/etc/rippled/rippled.cfg
- 
-[Install]
-WantedBy=multi-user.target

cfg/rippled.init

@@ -1,114 +0,0 @@
-#!/bin/sh
-
-### BEGIN INIT INFO
-# Provides:          ripple
-# Required-Start:    $local_fs $remote_fs $network $syslog
-# Required-Stop:     $local_fs $remote_fs $network $syslog
-# Default-Start:     2 3 4 5
-# Default-Stop:      0 1 6
-# Short-Description: starts the ripple network node
-# Description:       starts rippled using start-stop-daemon
-### END INIT INFO
-
-set -e
-
-NAME=rippled
-USER="rippled"
-GROUP="rippled"
-PIDFILE=/var/run/$NAME.pid
-DAEMON=/usr/local/sbin/rippled
-DAEMON_OPTS="--conf /etc/ripple/rippled.cfg"
-NET_OPTS="--net $DAEMON_OPTS"
-LOGDIR="/var/log/rippled"
-DBDIR="/var/db/rippled/db/hyperldb"
-
-export PATH="${PATH:+$PATH:}/usr/sbin:/sbin"
-
-# I wish it didn't come down to this, but this is the easiest way to ensure
-# sanity of an install.
-if [ ! -d $LOGDIR ]; then
-	mkdir -p $LOGDIR
-	chown $USER:$GROUP $LOGDIR
-fi
-if [ ! -d $DBDIR ]; then
-	mkdir -p $DBDIR
-	chown -R $USER:$GROUP $DBDIR
-fi
-
-case "$1" in
-    start)
-        echo -n "Starting daemon: "$NAME
-        start-stop-daemon --start --quiet --background -m --pidfile $PIDFILE \
-            --exec $DAEMON --chuid $USER --group $GROUP --verbose -- $NET_OPTS
-        echo "."
-        ;;
-
-    stop)
-        echo -n "Stopping daemon: "$NAME
-        $DAEMON $DAEMON_OPTS stop
-        rm -f $PIDFILE
-        echo "."
-        ;;
-
-    restart)
-        echo -n "Restarting daemon: "$NAME
-        $DAEMON $DAEMON_OPTS stop
-        rm -f $PIDFILE
-        start-stop-daemon --start --quiet --background -m --pidfile $PIDFILE \
-            --exec $DAEMON --chuid $USER --group $GROUP -- $NET_OPTS
-        echo "."
-        ;;
-
-    status)
-        echo "Status of $NAME:"
-        echo -n "PID of $NAME: "
-        if [ -f "$PIDFILE" ]; then
-                cat $PIDFILE
-                $DAEMON $DAEMON_OPTS server_info
-        else
-                echo "$NAME not running."
-        fi
-        echo "."
-        ;;
-
-    fetch)
-        echo "$NAME ledger fetching info:"
-        $DAEMON $DAEMON_OPTS fetch_info
-        echo "."
-        ;;
-
-    uptime)
-        echo "$NAME uptime:"
-        $DAEMON $DAEMON_OPTS get_counts
-        echo "."
-        ;;
-
-    startconfig)
-        echo "$NAME is being started with the following command line:"
-        echo "$DAEMON $NET_OPTS"
-        echo "."
-        ;;
-
-    command)
-        # Truncate the script's argument vector by one position to get rid of
-        # this entry.
-        shift
-
-        # Pass the remainder of the argument vector to rippled.
-        $DAEMON $DAEMON_OPTS "$@"
-        echo "."
-        ;;
-
-    test)
-        $DAEMON $DAEMON_OPTS ping
-        echo "."
-        ;;
-
-    *)
-        echo "Usage: $0 {start|stop|restart|status|fetch|uptime|startconfig|"
-        echo "           command|test}"
-        exit 1
-esac
-
-exit 0
-

cfg/validators-example.txt

@@ -1,12 +1,11 @@
 #
 # Default validators.txt
 #
-# A list of domains to bootstrap a nodes UNLs or for clients to indirectly
-# locate IPs to contact the Ripple network.
+# This file is located in the same folder as your rippled.cfg file
+# and defines which validators your server trusts not to collude.
 #
-# This file is UTF-8 with Dos, UNIX, or Mac style end of lines.
+# This file is UTF-8 with DOS, UNIX, or Mac style line endings.
 # Blank lines and lines starting with a '#' are ignored.
-# All other lines should be hankos or domain names.
 #
 #
 #
@@ -14,10 +13,8 @@
 #
 #   List of the validation public keys of nodes to always accept as validators.
 #
-#   The latest list of recommended validators can be obtained from
-#   https://ripple.com/ripple.txt
-#
-#   See also https://wiki.ripple.com/Ripple.txt
+#   Manually listing validator keys is not recommended for production networks.
+#   See validator_list_sites and validator_list_keys below.
 #
 #   Examples:
 #    n9KorY8QtTdRx7TVDpwnG9NvyxsDwHUKUEeDLY3AkiGncVaSXZi5
@@ -29,7 +26,9 @@
 #
 #   Examples:
 #    https://vl.ripple.com
+#    https://vl.xrplf.org
 #    http://127.0.0.1:8000
+#    file:///etc/opt/ripple/vl.txt
 #
 # [validator_list_keys]
 #
@@ -40,21 +39,30 @@
 #   Validator list keys should be hex-encoded.
 #
 #   Examples:
-#    ed499d732bded01504a7407c224412ef550cc1ade638a4de4eb88af7c36cb8b282
-#    0202d3f36a801349f3be534e3f64cfa77dede6e1b6310a0b48f40f20f955cec945
-#    02dd8b7075f64d77d9d2bdb88da364f29fcd975f9ea6f21894abcc7564efda8054
+#    ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
+#    ED307A760EE34F2D0CAA103377B1969117C38B8AA0AA1E2A24DAC1F32FC97087ED
 #
 
 # The default validator list publishers that the rippled instance
 # trusts.
+#
+# WARNING: Changing these values can cause your rippled instance to see a
+#          validated ledger that contradicts other rippled 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://unl.xrplf.org
 
 [validator_list_keys]
+#vl.ripple.com
 ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
+#unl.xrplf.org
+ED42AEC58B701EEBB77356FFFEC26F83C1F0407263530F068C7C73D392C7E06FD1
 
-# To use the XRP test network (see https://ripple.com/build/xrp-test-net/),
+# To use the test network (see https://xrpl.org/connect-your-rippled-to-the-xrp-test-net.html),
 # use the following configuration instead:
 #
 # [validator_list_sites]
@@ -62,3 +70,21 @@ ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
 #
 # [validator_list_keys]
 # ED264807102805220DA0F312E71FC2C69E1552C9C5790F6C25E3729DEB573D5860
+
+
+# [validator_list_threshold]
+#
+#   Minimum number of validator lists on which a validator must be listed in
+#   order to be used.
+#
+#   This can be set explicitly to any positive integer number not greater than
+#   the size of [validator_list_keys]. If it is not set, or set to 0, the
+#   value will be calculated at startup from the size of [validator_list_keys],
+#   where the calculation is:
+#
+#     threshold = size(validator_list_keys) < 3
+#       ? 1
+#       : floor(size(validator_list_keys) / 2) + 1
+
+[validator_list_threshold]
+0

cmake/CMakeFuncs.cmake

@@ -0,0 +1,48 @@
+macro(group_sources_in source_dir curdir)
+  file(GLOB children RELATIVE ${source_dir}/${curdir}
+    ${source_dir}/${curdir}/*)
+  foreach (child ${children})
+    if (IS_DIRECTORY ${source_dir}/${curdir}/${child})
+      group_sources_in(${source_dir} ${curdir}/${child})
+    else()
+      string(REPLACE "/" "\\" groupname ${curdir})
+      source_group(${groupname} FILES
+        ${source_dir}/${curdir}/${child})
+    endif()
+  endforeach()
+endmacro()
+
+macro(group_sources curdir)
+  group_sources_in(${PROJECT_SOURCE_DIR} ${curdir})
+endmacro()
+
+macro (exclude_from_default target_)
+  set_target_properties (${target_} PROPERTIES EXCLUDE_FROM_ALL ON)
+  set_target_properties (${target_} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
+endmacro ()
+
+macro (exclude_if_included target_)
+  get_directory_property(has_parent PARENT_DIRECTORY)
+  if (has_parent)
+    exclude_from_default (${target_})
+  endif ()
+endmacro ()
+
+find_package(Git)
+
+function (git_branch branch_val)
+  if (NOT GIT_FOUND)
+    return ()
+  endif ()
+  set (_branch "")
+  execute_process (COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
+                   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                   RESULT_VARIABLE _git_exit_code
+                   OUTPUT_VARIABLE _temp_branch
+                   OUTPUT_STRIP_TRAILING_WHITESPACE
+                   ERROR_QUIET)
+  if (_git_exit_code EQUAL 0)
+    set (_branch ${_temp_branch})
+  endif ()
+  set (${branch_val} "${_branch}" PARENT_SCOPE)
+endfunction ()

cmake/CodeCoverage.cmake

@@ -0,0 +1,453 @@
+# 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
+#
+# 2024-04-03, Bronek Kozicki
+#     - add support for output formats: jacoco, clover, lcov
+#
+# 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 jacoco clover
+#                                            #  json-summary json-details coveralls csv
+#                                            #  txt html-single html-nested html-details
+#                                            #  lcov (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)
+        elseif(Coverage_FORMAT STREQUAL "lcov")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
+        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 "jacoco")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty )
+    elseif(Coverage_FORMAT STREQUAL "clover")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty )
+    elseif(Coverage_FORMAT STREQUAL "lcov")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "json-summary")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)
+    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()

cmake/RippleConfig.cmake

@@ -0,0 +1,56 @@
+include (CMakeFindDependencyMacro)
+# need to represent system dependencies of the lib here
+#[=========================================================[
+  Boost
+#]=========================================================]
+if (static OR APPLE OR MSVC)
+  set (Boost_USE_STATIC_LIBS ON)
+endif ()
+set (Boost_USE_MULTITHREADED ON)
+if (static OR MSVC)
+  set (Boost_USE_STATIC_RUNTIME ON)
+else ()
+  set (Boost_USE_STATIC_RUNTIME OFF)
+endif ()
+find_dependency (Boost 1.70
+  COMPONENTS
+    chrono
+    container
+    context
+    coroutine
+    date_time
+    filesystem
+    program_options
+    regex
+    system
+    thread)
+#[=========================================================[
+  OpenSSL
+#]=========================================================]
+if (NOT DEFINED OPENSSL_ROOT_DIR)
+  if (DEFINED ENV{OPENSSL_ROOT})
+    set (OPENSSL_ROOT_DIR $ENV{OPENSSL_ROOT})
+  elseif (APPLE)
+    find_program (homebrew brew)
+    if (homebrew)
+      execute_process (COMMAND ${homebrew} --prefix openssl
+        OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    endif ()
+  endif ()
+  file (TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" OPENSSL_ROOT_DIR)
+endif ()
+
+if (static OR APPLE OR MSVC)
+  set (OPENSSL_USE_STATIC_LIBS ON)
+endif ()
+set (OPENSSL_MSVC_STATIC_RT ON)
+find_dependency (OpenSSL 1.1.1 REQUIRED)
+find_dependency (ZLIB)
+find_dependency (date)
+if (TARGET ZLIB::ZLIB)
+  set_target_properties(OpenSSL::Crypto PROPERTIES
+    INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
+endif ()
+
+include ("${CMAKE_CURRENT_LIST_DIR}/RippleTargets.cmake")

cmake/RippledCompiler.cmake

@@ -0,0 +1,202 @@
+#[===================================================================[
+   setup project-wide compiler settings
+#]===================================================================]
+
+#[=========================================================[
+   TODO some/most of these common settings belong in a
+   toolchain file, especially the ABI-impacting ones
+#]=========================================================]
+add_library (common INTERFACE)
+add_library (Ripple::common ALIAS common)
+# add a single global dependency on this interface lib
+link_libraries (Ripple::common)
+set_target_properties (common
+  PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+target_compile_definitions (common
+  INTERFACE
+    $<$<CONFIG:Debug>:DEBUG _DEBUG>
+    $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>)
+    # ^^^^ NOTE: CMAKE release builds already have NDEBUG
+    # defined, so no need to add it explicitly except for
+    # this special case of (profile ON) and (assert OFF)
+    # -- presumably this is because we don't want profile
+    # builds asserting unless asserts were specifically
+    # requested
+
+if (MSVC)
+  # remove existing exception flag since we set it to -EHa
+  string (REGEX REPLACE "[-/]EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+  foreach (var_
+      CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+      CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
+
+    # also remove dynamic runtime
+    string (REGEX REPLACE "[-/]MD[d]*" " " ${var_} "${${var_}}")
+
+    # /ZI (Edit & Continue debugging information) is incompatible with Gy-
+    string (REPLACE "/ZI" "/Zi" ${var_} "${${var_}}")
+
+    # omit debug info completely under CI (not needed)
+    if (is_ci)
+      string (REPLACE "/Zi" " " ${var_} "${${var_}}")
+    endif ()
+  endforeach ()
+
+  target_compile_options (common
+    INTERFACE
+      -bigobj            # Increase object file max size
+      -fp:precise        # Floating point behavior
+      -Gd                # __cdecl calling convention
+      -Gm-               # Minimal rebuild: disabled
+      -Gy-               # Function level linking: disabled
+      -MP                # Multiprocessor compilation
+      -openmp-           # pragma omp: disabled
+      -errorReport:none  # No error reporting to Internet
+      -nologo            # Suppress login banner
+      -wd4018            # Disable signed/unsigned comparison warnings
+      -wd4244            # Disable float to int possible loss of data warnings
+      -wd4267            # Disable size_t to T possible loss of data warnings
+      -wd4800            # Disable C4800(int to bool performance)
+      -wd4503            # Decorated name length exceeded, name was truncated
+      $<$<COMPILE_LANGUAGE:CXX>:
+        -EHa
+        -GR
+      >
+      $<$<CONFIG:Release>:-Ox>
+      $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
+        -GS
+        -Zc:forScope
+      >
+      # static runtime
+      $<$<CONFIG:Debug>:-MTd>
+      $<$<NOT:$<CONFIG:Debug>>:-MT>
+      $<$<BOOL:${werr}>:-WX>
+      )
+  target_compile_definitions (common
+    INTERFACE
+      _WIN32_WINNT=0x6000
+      _SCL_SECURE_NO_WARNINGS
+      _CRT_SECURE_NO_WARNINGS
+      WIN32_CONSOLE
+      WIN32_LEAN_AND_MEAN
+      NOMINMAX
+      # TODO: Resolve these warnings, don't just silence them
+      _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
+      $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:_CRTDBG_MAP_ALLOC>)
+  target_link_libraries (common
+    INTERFACE
+      -errorreport:none
+      -machine:X64)
+else ()
+  # HACK : because these need to come first, before any warning demotion
+  string (APPEND CMAKE_CXX_FLAGS " -Wall -Wdeprecated")
+  if (wextra)
+    string (APPEND CMAKE_CXX_FLAGS " -Wextra -Wno-unused-parameter")
+  endif ()
+  # not MSVC
+  target_compile_options (common
+    INTERFACE
+      $<$<BOOL:${werr}>:-Werror>
+      $<$<COMPILE_LANGUAGE:CXX>:
+        -frtti
+        -Wnon-virtual-dtor
+      >
+      -Wno-sign-compare
+      -Wno-char-subscripts
+      -Wno-format
+      -Wno-unused-local-typedefs
+      -fstack-protector
+      $<$<BOOL:${is_gcc}>:
+        -Wno-unused-but-set-variable
+        -Wno-deprecated
+      >
+      $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
+      # tweak gcc optimization for debug
+      $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
+      # Add debug symbols to release config
+      $<$<CONFIG:Release>:-g>)
+  target_link_libraries (common
+    INTERFACE
+      -rdynamic
+      $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
+      # link to static libc/c++ iff:
+      #   * static option set and
+      #   * NOT APPLE (AppleClang does not support static libc/c++) and
+      #   * NOT san (sanitizers typically don't work with static libc/c++)
+      $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${san}>>>:
+      -static-libstdc++
+      -static-libgcc
+      >)
+endif ()
+
+# Antithesis instrumentation will only be built and deployed using machines running Linux.
+if (voidstar)
+  if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    message(FATAL_ERROR "Antithesis instrumentation requires Debug build type, aborting...")
+  elseif (NOT is_linux)
+    message(FATAL_ERROR "Antithesis instrumentation requires Linux, aborting...")
+  elseif (NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0))
+    message(FATAL_ERROR "Antithesis instrumentation requires Clang version 16 or later, aborting...")
+  endif ()
+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)
+  # use gold linker if available
+  execute_process (
+    COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
+    ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+    #[=========================================================[
+       NOTE: THE gold linker inserts -rpath as DT_RUNPATH by
+       default intead of DT_RPATH, so you might have slightly
+       unexpected runtime ld behavior if you were expecting
+       DT_RPATH.  Specify --disable-new-dtags to gold if you do
+       not want the default DT_RUNPATH behavior. This rpath
+       treatment as well as static/dynamic selection means that
+       gold does not currently have ideal default behavior when
+       we are using jemalloc. Thus for simplicity we don't use
+       it when jemalloc is requested. An alternative to
+       disabling would be to figure out all the settings
+       required to make gold play nicely with jemalloc.
+    #]=========================================================]
+  if (("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
+    target_link_libraries (common
+      INTERFACE
+        -fuse-ld=gold
+        -Wl,--no-as-needed
+        #[=========================================================[
+           see https://bugs.launchpad.net/ubuntu/+source/eglibc/+bug/1253638/comments/5
+           DT_RUNPATH does not work great for transitive
+           dependencies (of which boost has a few) - so just
+           switch to DT_RPATH if doing dynamic linking with gold
+        #]=========================================================]
+        $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
+  endif ()
+  unset (LD_VERSION)
+elseif (use_lld)
+  # use lld linker if available
+  execute_process (
+    COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
+    ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+  if ("${LD_VERSION}" MATCHES "LLD")
+    target_link_libraries (common INTERFACE -fuse-ld=lld)
+  endif ()
+  unset (LD_VERSION)
+endif()
+
+
+if (assert)
+  foreach (var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
+    STRING (REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")
+  endforeach ()
+endif ()

cmake/RippledCore.cmake

@@ -0,0 +1,194 @@
+#[===================================================================[
+  Exported targets.
+#]===================================================================]
+
+include(target_protobuf_sources)
+
+# 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)
+set_target_properties(xrpl.libpb PROPERTIES UNITY_BUILD OFF)
+target_protobuf_sources(xrpl.libpb xrpl/proto
+  LANGUAGE cpp
+  IMPORT_DIRS include/xrpl/proto
+  PROTOS include/xrpl/proto/ripple.proto
+)
+
+file(GLOB_RECURSE protos "include/xrpl/proto/org/*.proto")
+target_protobuf_sources(xrpl.libpb xrpl/proto
+  LANGUAGE cpp
+  IMPORT_DIRS include/xrpl/proto
+  PROTOS "${protos}"
+)
+target_protobuf_sources(xrpl.libpb xrpl/proto
+  LANGUAGE grpc
+  IMPORT_DIRS include/xrpl/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++
+)
+
+# TODO: Clean up the number of library targets later.
+add_library(xrpl.imports.main INTERFACE)
+
+target_link_libraries(xrpl.imports.main
+  INTERFACE
+    LibArchive::LibArchive
+    OpenSSL::Crypto
+    Ripple::boost
+    Ripple::opts
+    Ripple::syslibs
+    absl::random_random
+    date::date
+    ed25519::ed25519
+    secp256k1::secp256k1
+    xrpl.libpb
+    xxHash::xxhash
+    $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
+)
+
+include(add_module)
+include(target_link_modules)
+
+# Level 01
+add_module(xrpl beast)
+target_link_libraries(xrpl.libxrpl.beast PUBLIC
+  xrpl.imports.main
+  xrpl.libpb
+)
+
+# Level 02
+add_module(xrpl basics)
+target_link_libraries(xrpl.libxrpl.basics PUBLIC xrpl.libxrpl.beast)
+
+# Level 03
+add_module(xrpl json)
+target_link_libraries(xrpl.libxrpl.json PUBLIC xrpl.libxrpl.basics)
+
+add_module(xrpl crypto)
+target_link_libraries(xrpl.libxrpl.crypto PUBLIC xrpl.libxrpl.basics)
+
+# Level 04
+add_module(xrpl protocol)
+target_link_libraries(xrpl.libxrpl.protocol PUBLIC
+  xrpl.libxrpl.crypto
+  xrpl.libxrpl.json
+)
+
+# Level 05
+add_module(xrpl resource)
+target_link_libraries(xrpl.libxrpl.resource PUBLIC xrpl.libxrpl.protocol)
+
+add_module(xrpl server)
+target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol)
+
+
+add_library(xrpl.libxrpl)
+set_target_properties(xrpl.libxrpl PROPERTIES OUTPUT_NAME xrpl)
+
+add_library(xrpl::libxrpl ALIAS xrpl.libxrpl)
+
+file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp"
+)
+target_sources(xrpl.libxrpl PRIVATE ${sources})
+
+target_link_modules(xrpl PUBLIC
+  basics
+  beast
+  crypto
+  json
+  protocol
+  resource
+  server
+)
+
+# All headers in libxrpl are in modules.
+# Uncomment this stanza if you have not yet moved new headers into a module.
+# target_include_directories(xrpl.libxrpl
+#   PRIVATE
+#     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+#   PUBLIC
+#     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+#     $<INSTALL_INTERFACE:include>)
+
+if(xrpld)
+  add_executable(rippled)
+  if(tests)
+    target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
+    target_compile_definitions(rippled PRIVATE
+                                       UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
+    )
+  endif()
+  target_include_directories(rippled
+    PRIVATE
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+  )
+
+  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp"
+  )
+  target_sources(rippled PRIVATE ${sources})
+
+  if(tests)
+    file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+      "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp"
+    )
+    target_sources(rippled PRIVATE ${sources})
+  endif()
+
+  target_link_libraries(rippled
+    Ripple::boost
+    Ripple::opts
+    Ripple::libs
+    xrpl.libxrpl
+  )
+  exclude_if_included(rippled)
+  # define a macro for tests that might need to
+  # be exluded or run differently in CI environment
+  if(is_ci)
+    target_compile_definitions(rippled PRIVATE RIPPLED_RUNNING_IN_CI)
+  endif ()
+
+  if(voidstar)
+    target_compile_options(rippled
+      PRIVATE
+        -fsanitize-coverage=trace-pc-guard
+    )
+    # rippled requires access to antithesis-sdk-cpp implementation file
+    # antithesis_instrumentation.h, which is not exported as INTERFACE
+    target_include_directories(rippled
+      PRIVATE
+        ${CMAKE_SOURCE_DIR}/external/antithesis-sdk
+    )
+  endif()
+
+  # any files that don't play well with unity should be added here
+  if(tests)
+    set_source_files_properties(
+      # these two seem to produce conflicts in beast teardown template methods
+      src/test/rpc/ValidatorRPC_test.cpp
+      src/test/ledger/Invariants_test.cpp
+      PROPERTIES SKIP_UNITY_BUILD_INCLUSION TRUE)
+  endif()
+endif()

cmake/RippledCov.cmake

@@ -0,0 +1,38 @@
+#[===================================================================[
+   coverage report target
+#]===================================================================]
+
+if(NOT coverage)
+  message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+  message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
+  return()
+endif()
+
+include(CodeCoverage)
+
+# 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`)
+
+set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
+if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
+  separate_arguments(GCOVR_ADDITIONAL_ARGS)
+endif()
+
+list(APPEND GCOVR_ADDITIONAL_ARGS
+  --exclude-throw-branches
+  --exclude-noncode-lines
+  --exclude-unreachable-branches -s
+  -j ${coverage_test_parallelism})
+
+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" "include/xrpl/beast/test" "include/xrpl/beast/unit_test" "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+  DEPENDENCIES rippled
+)

cmake/RippledDocs.cmake

@@ -0,0 +1,85 @@
+#[===================================================================[
+   docs target (optional)
+#]===================================================================]
+
+option(with_docs "Include the docs target?" FALSE)
+
+if(NOT (with_docs OR only_docs))
+  return()
+endif()
+
+find_package(Doxygen)
+if(NOT TARGET Doxygen::doxygen)
+  message(STATUS "doxygen executable not found -- skipping docs target")
+  return()
+endif()
+
+set(doxygen_output_directory "${CMAKE_BINARY_DIR}/docs")
+set(doxygen_include_path "${CMAKE_CURRENT_SOURCE_DIR}/src")
+set(doxygen_index_file "${doxygen_output_directory}/html/index.html")
+set(doxyfile "${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile")
+
+file(GLOB_RECURSE doxygen_input
+  docs/*.md
+  include/*.h
+  include/*.cpp
+  include/*.md
+  src/*.h
+  src/*.cpp
+  src/*.md
+  Builds/*.md
+  *.md)
+list(APPEND doxygen_input
+  external/README.md
+  )
+set(dependencies "${doxygen_input}" "${doxyfile}")
+
+function(verbose_find_path variable name)
+  # find_path sets a CACHE variable, so don't try using a "local" variable.
+  find_path(${variable} "${name}" ${ARGN})
+  if(NOT ${variable})
+    message(NOTICE "could not find ${name}")
+  else()
+    message(STATUS "found ${name}: ${${variable}}/${name}")
+  endif()
+endfunction()
+
+verbose_find_path(doxygen_plantuml_jar_path plantuml.jar PATH_SUFFIXES share/plantuml)
+verbose_find_path(doxygen_dot_path dot)
+
+# https://en.cppreference.com/w/Cppreference:Archives
+# https://stackoverflow.com/questions/60822559/how-to-move-a-file-download-from-configure-step-to-build-step
+set(download_script "${CMAKE_BINARY_DIR}/docs/download-cppreference.cmake")
+file(WRITE
+  "${download_script}"
+  "file(DOWNLOAD \
+    http://upload.cppreference.com/mwiki/images/b/b2/html_book_20190607.zip \
+    ${CMAKE_BINARY_DIR}/docs/cppreference.zip \
+    EXPECTED_HASH MD5=82b3a612d7d35a83e3cb1195a63689ab \
+  )\n \
+  execute_process( \
+    COMMAND \"${CMAKE_COMMAND}\" -E tar -xf cppreference.zip \
+  )\n"
+)
+set(tagfile "${CMAKE_BINARY_DIR}/docs/cppreference-doxygen-web.tag.xml")
+add_custom_command(
+  OUTPUT "${tagfile}"
+  COMMAND "${CMAKE_COMMAND}" -P "${download_script}"
+  WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/docs"
+)
+set(doxygen_tagfiles "${tagfile}=http://en.cppreference.com/w/")
+
+add_custom_command(
+  OUTPUT "${doxygen_index_file}"
+  COMMAND "${CMAKE_COMMAND}" -E env
+    "DOXYGEN_OUTPUT_DIRECTORY=${doxygen_output_directory}"
+    "DOXYGEN_INCLUDE_PATH=${doxygen_include_path}"
+    "DOXYGEN_TAGFILES=${doxygen_tagfiles}"
+    "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}"
+    "DOXYGEN_DOT_PATH=${doxygen_dot_path}"
+    "${DOXYGEN_EXECUTABLE}" "${doxyfile}"
+  WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+  DEPENDS "${dependencies}" "${tagfile}")
+add_custom_target(docs
+  DEPENDS "${doxygen_index_file}"
+  SOURCES "${dependencies}")

cmake/RippledInstall.cmake

@@ -0,0 +1,81 @@
+#[===================================================================[
+   install stuff
+#]===================================================================]
+
+include(create_symbolic_link)
+
+install (
+  TARGETS
+    common
+    opts
+    ripple_syslibs
+    ripple_boost
+    xrpl.imports.main
+    xrpl.libpb
+    xrpl.libxrpl.basics
+    xrpl.libxrpl.beast
+    xrpl.libxrpl.crypto
+    xrpl.libxrpl.json
+    xrpl.libxrpl.protocol
+    xrpl.libxrpl.resource
+    xrpl.libxrpl.server
+    xrpl.libxrpl
+    antithesis-sdk-cpp
+  EXPORT RippleExports
+  LIBRARY DESTINATION lib
+  ARCHIVE DESTINATION lib
+  RUNTIME DESTINATION bin
+  INCLUDES DESTINATION include)
+
+install(
+  DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl"
+  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+install(CODE "
+  set(CMAKE_MODULE_PATH \"${CMAKE_MODULE_PATH}\")
+  include(create_symbolic_link)
+  create_symbolic_link(xrpl \
+    \${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/ripple)
+")
+
+install (EXPORT RippleExports
+  FILE RippleTargets.cmake
+  NAMESPACE Ripple::
+  DESTINATION lib/cmake/ripple)
+include (CMakePackageConfigHelpers)
+write_basic_package_version_file (
+  RippleConfigVersion.cmake
+  VERSION ${rippled_version}
+  COMPATIBILITY SameMajorVersion)
+
+if (is_root_project AND TARGET rippled)
+  install (TARGETS rippled RUNTIME DESTINATION bin)
+  set_target_properties(rippled PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
+  # sample configs should not overwrite existing files
+  # install if-not-exists workaround as suggested by
+  # https://cmake.org/Bug/view.php?id=12646
+  install(CODE "
+    macro (copy_if_not_exists SRC DEST NEWNAME)
+      if (NOT EXISTS \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${DEST}/\${NEWNAME}\")
+        file (INSTALL FILE_PERMISSIONS OWNER_READ OWNER_WRITE DESTINATION \"\${CMAKE_INSTALL_PREFIX}/\${DEST}\" FILES \"\${SRC}\" RENAME \"\${NEWNAME}\")
+      else ()
+        message (\"-- Skipping : \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${DEST}/\${NEWNAME}\")
+      endif ()
+    endmacro()
+    copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/rippled-example.cfg\" etc rippled.cfg)
+    copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/validators-example.txt\" etc validators.txt)
+  ")
+  install(CODE "
+    set(CMAKE_MODULE_PATH \"${CMAKE_MODULE_PATH}\")
+    include(create_symbolic_link)
+    create_symbolic_link(rippled${suffix} \
+      \${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/xrpld${suffix})
+  ")
+endif ()
+
+install (
+  FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/RippleConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/RippleConfigVersion.cmake
+  DESTINATION lib/cmake/ripple)

cmake/RippledInterface.cmake

@@ -0,0 +1,101 @@
+#[===================================================================[
+   rippled compile options/settings via an interface library
+#]===================================================================]
+
+add_library (opts INTERFACE)
+add_library (Ripple::opts ALIAS opts)
+target_compile_definitions (opts
+  INTERFACE
+    BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
+    BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+    BOOST_CONTAINER_FWD_BAD_DEQUE
+    HAS_UNCAUGHT_EXCEPTIONS=1
+    $<$<BOOL:${boost_show_deprecated}>:
+      BOOST_ASIO_NO_DEPRECATED
+      BOOST_FILESYSTEM_NO_DEPRECATED
+    >
+    $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
+      BOOST_COROUTINES_NO_DEPRECATION_WARNING
+      BOOST_BEAST_ALLOW_DEPRECATED
+      BOOST_FILESYSTEM_DEPRECATED
+    >
+    $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
+    $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
+    $<$<BOOL:${single_io_service_thread}>:RIPPLE_SINGLE_IO_SERVICE_THREAD=1>
+    $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>)
+target_compile_options (opts
+  INTERFACE
+    $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
+    $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
+    $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<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>
+    $<$<BOOL:${profile}>:-pg>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+
+if(jemalloc)
+  find_package(jemalloc REQUIRED)
+  target_compile_definitions(opts INTERFACE PROFILE_JEMALLOC)
+  target_link_libraries(opts INTERFACE jemalloc::jemalloc)
+endif ()
+
+if (san)
+  target_compile_options (opts
+    INTERFACE
+      # sanitizers recommend minimum of -O1 for reasonable performance
+      $<$<CONFIG:Debug>:-O1>
+      ${SAN_FLAG}
+      -fno-omit-frame-pointer)
+  target_compile_definitions (opts
+    INTERFACE
+      $<$<STREQUAL:${san},address>:SANITIZER=ASAN>
+      $<$<STREQUAL:${san},thread>:SANITIZER=TSAN>
+      $<$<STREQUAL:${san},memory>:SANITIZER=MSAN>
+      $<$<STREQUAL:${san},undefined>:SANITIZER=UBSAN>)
+  target_link_libraries (opts INTERFACE ${SAN_FLAG} ${SAN_LIB})
+endif ()
+
+#[===================================================================[
+   rippled transitive library deps via an interface library
+#]===================================================================]
+
+add_library (ripple_syslibs INTERFACE)
+add_library (Ripple::syslibs ALIAS ripple_syslibs)
+target_link_libraries (ripple_syslibs
+  INTERFACE
+    $<$<BOOL:${MSVC}>:
+      legacy_stdio_definitions.lib
+      Shlwapi
+      kernel32
+      user32
+      gdi32
+      winspool
+      comdlg32
+      advapi32
+      shell32
+      ole32
+      oleaut32
+      uuid
+      odbc32
+      odbccp32
+      crypt32
+    >
+    $<$<NOT:$<BOOL:${MSVC}>>:dl>
+    $<$<NOT:$<OR:$<BOOL:${MSVC}>,$<BOOL:${APPLE}>>>:rt>)
+
+if (NOT MSVC)
+  set (THREADS_PREFER_PTHREAD_FLAG ON)
+  find_package (Threads)
+  target_link_libraries (ripple_syslibs INTERFACE Threads::Threads)
+endif ()
+
+add_library (ripple_libs INTERFACE)
+add_library (Ripple::libs ALIAS ripple_libs)
+target_link_libraries (ripple_libs INTERFACE Ripple::syslibs)

cmake/RippledSanity.cmake

@@ -0,0 +1,80 @@
+#[===================================================================[
+   convenience variables and sanity checks
+#]===================================================================]
+
+include(ProcessorCount)
+
+if (NOT ep_procs)
+  ProcessorCount(ep_procs)
+  if (ep_procs GREATER 1)
+    # never use more than half of cores for EP builds
+    math (EXPR ep_procs "${ep_procs} / 2")
+    message (STATUS "Using ${ep_procs} cores for ExternalProject builds.")
+  endif ()
+endif ()
+get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+
+set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
+if (NOT is_multiconfig)
+  if (NOT CMAKE_BUILD_TYPE)
+    message (STATUS "Build type not specified - defaulting to Release")
+    set (CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
+  elseif (NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release))
+    # for simplicity, these are the only two config types we care about. Limiting
+    # the build types simplifies dealing with external project builds especially
+    message (FATAL_ERROR " *** Only Debug or Release build types are currently supported ***")
+  endif ()
+endif ()
+
+get_directory_property(has_parent PARENT_DIRECTORY)
+if (has_parent)
+  set (is_root_project OFF)
+else ()
+  set (is_root_project ON)
+endif ()
+
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES ".*Clang") # both Clang and AppleClang
+  set (is_clang TRUE)
+  if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND
+         CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+    message (FATAL_ERROR "This project requires clang 8 or later")
+  endif ()
+  # TODO min AppleClang version check ?
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+  set (is_gcc TRUE)
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+    message (FATAL_ERROR "This project requires GCC 8 or later")
+  endif ()
+endif ()
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  set (is_linux TRUE)
+else ()
+  set (is_linux FALSE)
+endif ()
+
+if ("$ENV{CI}" STREQUAL "true" OR "$ENV{CONTINUOUS_INTEGRATION}" STREQUAL "true")
+  set (is_ci TRUE)
+else ()
+  set (is_ci FALSE)
+endif ()
+
+# check for in-source build and fail
+if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+  message (FATAL_ERROR "Builds (in-source) are not allowed in "
+    "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
+    "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory.")
+endif ()
+
+if (MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
+  message (FATAL_ERROR "Visual Studio 32-bit build is not supported.")
+endif ()
+
+if (NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+  message (FATAL_ERROR "Rippled requires a 64 bit target architecture.\n"
+    "The most likely cause of this warning is trying to build rippled with a 32-bit OS.")
+endif ()
+
+if (APPLE AND NOT HOMEBREW)
+  find_program (HOMEBREW brew)
+endif ()

cmake/RippledSettings.cmake

@@ -0,0 +1,140 @@
+#[===================================================================[
+   declare user options/settings
+#]===================================================================]
+
+include(ProcessorCount)
+
+ProcessorCount(PROCESSOR_COUNT)
+
+option(assert "Enables asserts, even in release builds" OFF)
+
+option(xrpld "Build xrpld" ON)
+
+option(tests "Build tests" ON)
+if(tests)
+  # This setting allows making a separate workflow to test fees other than default 10
+  if(NOT UNIT_TEST_REFERENCE_FEE)
+    set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
+  endif()
+endif()
+
+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()
+  set(CMAKE_UNITY_BUILD ON CACHE BOOL "Do a unity build")
+endif()
+if(is_clang AND is_linux)
+  option(voidstar "Enable Antithesis instrumentation." OFF)
+endif()
+if(is_gcc OR is_clang)
+  option(coverage "Generates coverage info." OFF)
+  option(profile "Add profiling flags" OFF)
+  set(coverage_test_parallelism "${PROCESSOR_COUNT}" CACHE STRING
+    "Unit tests parallelism for the purpose of coverage report.")
+  set(coverage_format "html-details" CACHE STRING
+    "Output format of the coverage report.")
+  set(coverage_extra_args "" CACHE STRING
+    "Additional arguments to pass to gcovr.")
+  set(coverage_test "" CACHE STRING
+    "On gcc & clang, the specific unit test(s) to run for coverage. Default is all tests.")
+  if(coverage_test AND NOT coverage)
+    set(coverage ON CACHE BOOL "gcc/clang only" FORCE)
+  endif()
+  option(wextra "compile with extra gcc/clang warnings enabled" ON)
+else()
+  set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
+  set(coverage OFF CACHE BOOL "gcc/clang only" FORCE)
+  set(wextra OFF CACHE BOOL "gcc/clang only" FORCE)
+endif()
+if(is_linux)
+  option(BUILD_SHARED_LIBS "build shared ripple libraries" OFF)
+  option(static "link protobuf, openssl, libc++, and boost statically" ON)
+  option(perf "Enables flags that assist with perf recording" OFF)
+  option(use_gold "enables detection of gold (binutils) linker" ON)
+  option(use_mold "enables detection of mold (binutils) linker" ON)
+else()
+  # we are not ready to allow shared-libs on windows because it would require
+  # export declarations. On macos it's more feasible, but static openssl
+  # produces odd linker errors, thus we disable shared lib builds for now.
+  set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared ripple libraries - OFF for win/macos" FORCE)
+  set(static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
+  set(perf OFF CACHE BOOL "perf flags, linux only" FORCE)
+  set(use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
+  set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
+endif()
+if(is_clang)
+  option(use_lld "enables detection of lld linker" ON)
+else()
+  set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
+endif()
+option(jemalloc "Enables jemalloc for heap profiling" OFF)
+option(werr "treat warnings as errors" OFF)
+option(local_protobuf
+  "Force a local build of protobuf instead of looking for an installed version." OFF)
+option(local_grpc
+  "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
+  "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
+  "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
+  "Prevents unit test definitions from being inserted into global table"
+  OFF)
+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
+  "Allow boost to fail on deprecated usage. Only useful if you're trying\
+  to find deprecated calls."
+  OFF)
+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()

cmake/RippledValidatorKeys.cmake

@@ -0,0 +1,22 @@
+option (validator_keys "Enables building of validator-keys-tool as a separate target (imported via FetchContent)" OFF)
+
+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")
+  endif ()
+  message (STATUS "tracking ValidatorKeys branch: ${current_branch}")
+
+  FetchContent_Declare (
+    validator_keys_src
+    GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
+    GIT_TAG        "${current_branch}"
+  )
+  FetchContent_GetProperties (validator_keys_src)
+  if (NOT validator_keys_src_POPULATED)
+    message (STATUS "Pausing to download ValidatorKeys...")
+    FetchContent_Populate (validator_keys_src)
+  endif ()
+  add_subdirectory (${validator_keys_src_SOURCE_DIR} ${CMAKE_BINARY_DIR}/validator-keys)
+endif ()

cmake/RippledVersion.cmake

@@ -0,0 +1,15 @@
+#[===================================================================[
+   read version from source
+#]===================================================================]
+
+file(STRINGS src/libxrpl/protocol/BuildInfo.cpp BUILD_INFO)
+foreach(line_ ${BUILD_INFO})
+  if(line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
+    set(rippled_version ${CMAKE_MATCH_1})
+  endif()
+endforeach()
+if(rippled_version)
+  message(STATUS "rippled version: ${rippled_version}")
+else()
+  message(FATAL_ERROR "unable to determine rippled version")
+endif()

cmake/add_module.cmake

@@ -0,0 +1,37 @@
+include(isolate_headers)
+
+# Create an OBJECT library target named
+#
+#   ${PROJECT_NAME}.lib${parent}.${name}
+#
+# with sources in src/lib${parent}/${name}
+# and headers in include/${parent}/${name}
+# that cannot include headers from other directories in include/
+# unless they come through linked libraries.
+#
+# add_module(parent a)
+# add_module(parent b)
+# target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
+function(add_module parent name)
+  set(target ${PROJECT_NAME}.lib${parent}.${name})
+  add_library(${target} OBJECT)
+  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp"
+  )
+  target_sources(${target} PRIVATE ${sources})
+  target_include_directories(${target} PUBLIC
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+  )
+  isolate_headers(
+    ${target}
+    "${CMAKE_CURRENT_SOURCE_DIR}/include"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}"
+    PUBLIC
+  )
+  isolate_headers(
+    ${target}
+    "${CMAKE_CURRENT_SOURCE_DIR}/src"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
+    PRIVATE
+  )
+endfunction()

cmake/create_symbolic_link.cmake

@@ -0,0 +1,20 @@
+# file(CREATE_SYMLINK) only works on Windows with administrator privileges.
+# https://stackoverflow.com/a/61244115/618906
+function(create_symbolic_link target link)
+  if(WIN32)
+    if(NOT IS_SYMLINK "${link}")
+      if(NOT IS_ABSOLUTE "${target}")
+        # Relative links work do not work on Windows.
+        set(target "${link}/../${target}")
+      endif()
+      file(TO_NATIVE_PATH "${target}" target)
+      file(TO_NATIVE_PATH "${link}" link)
+      execute_process(COMMAND cmd.exe /c mklink /J "${link}" "${target}")
+    endif()
+  else()
+    file(CREATE_LINK "${target}" "${link}" SYMBOLIC)
+  endif()
+  if(NOT IS_SYMLINK "${link}")
+    message(ERROR "failed to create symlink: <${link}>")
+  endif()
+endfunction()

cmake/deps/Boost.cmake

@@ -0,0 +1,53 @@
+find_package(Boost 1.82 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::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()

cmake/isolate_headers.cmake

@@ -0,0 +1,48 @@
+include(create_symbolic_link)
+
+# Consider include directory B nested under prefix A:
+#
+#     /path/to/A/then/to/B/...
+#
+# Call C the relative path from A to B.
+# C is what we want to write in `#include` directives:
+#
+#     #include <then/to/B/...>
+#
+# Examples, all from the `jobqueue` module:
+#
+#   - Library public headers:
+#     B = /include/xrpl/jobqueue
+#     A = /include/
+#     C = xrpl/jobqueue
+#
+#   - Library private headers:
+#     B = /src/libxrpl/jobqueue
+#     A = /src/
+#     C = libxrpl/jobqueue
+#
+#   - Test private headers:
+#     B = /tests/jobqueue
+#     A = /
+#     C = tests/jobqueue
+#
+# To isolate headers from each other,
+# we want to create a symlink Y that points to B,
+# within a subdirectory X of the `CMAKE_BINARY_DIR`,
+# that has the same relative path C between X and Y,
+# and then add X as an include directory of the target,
+# sometimes `PUBLIC` and sometimes `PRIVATE`.
+# The Cs are all guaranteed to be unique.
+# We can guarantee a unique X per target by using
+# `${CMAKE_CURRENT_BINARY_DIR}/include/${target}`.
+#
+# isolate_headers(target A B scope)
+function(isolate_headers target A B scope)
+  file(RELATIVE_PATH C "${A}" "${B}")
+  set(X "${CMAKE_CURRENT_BINARY_DIR}/modules/${target}")
+  set(Y "${X}/${C}")
+  cmake_path(GET Y PARENT_PATH parent)
+  file(MAKE_DIRECTORY "${parent}")
+  create_symbolic_link("${B}" "${Y}")
+  target_include_directories(${target} ${scope} "$<BUILD_INTERFACE:${X}>")
+endfunction()

cmake/target_link_modules.cmake

@@ -0,0 +1,24 @@
+# Link a library to its modules (see: `add_module`)
+# and remove the module sources from the library's sources.
+#
+# add_module(parent a)
+# add_module(parent b)
+# target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
+# add_library(project.libparent)
+# target_link_modules(parent PUBLIC a b)
+function(target_link_modules parent scope)
+  set(library ${PROJECT_NAME}.lib${parent})
+  foreach(name ${ARGN})
+    set(module ${library}.${name})
+    get_target_property(sources ${library} SOURCES)
+    list(LENGTH sources before)
+    get_target_property(dupes ${module} SOURCES)
+    list(LENGTH dupes expected)
+    list(REMOVE_ITEM sources ${dupes})
+    list(LENGTH sources after)
+    math(EXPR actual "${before} - ${after}")
+    message(STATUS "${module} with ${expected} sources took ${actual} sources from ${library}")
+    set_target_properties(${library} PROPERTIES SOURCES "${sources}")
+    target_link_libraries(${library} ${scope} ${module})
+  endforeach()
+endfunction()

cmake/target_protobuf_sources.cmake

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

conanfile.py

@@ -0,0 +1,178 @@
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+import re
+
+class Xrpl(ConanFile):
+    name = 'xrpl'
+
+    license = 'ISC'
+    author = 'John Freeman <jfreeman@ripple.com>'
+    url = 'https://github.com/xrplf/rippled'
+    description = 'The XRP Ledger'
+    settings = 'os', 'compiler', 'build_type', 'arch'
+    options = {
+        'assertions': [True, False],
+        'coverage': [True, False],
+        'fPIC': [True, False],
+        'jemalloc': [True, False],
+        'rocksdb': [True, False],
+        'shared': [True, False],
+        'static': [True, False],
+        'tests': [True, False],
+        'unity': [True, False],
+        'xrpld': [True, False],
+    }
+
+    requires = [
+        'date/3.0.3',
+        'grpc/1.50.1',
+        'libarchive/3.7.6',
+        'nudb/2.0.8',
+        'openssl/1.1.1v',
+        'soci/4.0.3',
+        'xxhash/0.8.2',
+        'zlib/1.3.1',
+    ]
+
+    tool_requires = [
+        'protobuf/3.21.9',
+    ]
+
+    default_options = {
+        'assertions': False,
+        'coverage': False,
+        'fPIC': True,
+        'jemalloc': False,
+        'rocksdb': True,
+        'shared': False,
+        'static': True,
+        'tests': False,
+        'unity': False,
+        'xrpld': 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,
+        'lz4/*:shared': False,
+        'openssl/*:shared': False,
+        'protobuf/*:shared': False,
+        'protobuf/*:with_zlib': True,
+        'rocksdb/*:enable_sse': False,
+        'rocksdb/*:lite': False,
+        'rocksdb/*:shared': False,
+        'rocksdb/*:use_rtti': True,
+        'rocksdb/*:with_jemalloc': False,
+        'rocksdb/*:with_lz4': True,
+        'rocksdb/*:with_snappy': True,
+        'snappy/*:shared': False,
+        'soci/*:shared': False,
+        'soci/*:with_sqlite3': True,
+        'soci/*:with_boost': True,
+        'xxhash/*:shared': False,
+    }
+
+    def set_version(self):
+        path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
+        regex = r'versionString\s?=\s?\"(.*)\"'
+        with open(path, 'r') as file:
+            matches = (re.search(regex, line) for line in file)
+            match = next(m for m in matches if m)
+            self.version = match.group(1)
+
+    def configure(self):
+        if self.settings.compiler == 'apple-clang':
+            self.options['boost'].visibility = 'global'
+
+    def requirements(self):
+        self.requires('boost/1.83.0', force=True)
+        self.requires('lz4/1.10.0', force=True)
+        self.requires('protobuf/3.21.9', force=True)
+        self.requires('sqlite3/3.47.0', force=True)
+        if self.options.jemalloc:
+            self.requires('jemalloc/5.3.0')
+        if self.options.rocksdb:
+            self.requires('rocksdb/9.7.3')
+
+    exports_sources = (
+        'CMakeLists.txt',
+        'bin/getRippledInfo',
+        'cfg/*',
+        'cmake/*',
+        'external/*',
+        'include/*',
+        'src/*',
+    )
+
+    def layout(self):
+        cmake_layout(self)
+        # Fix this setting to follow the default introduced in Conan 1.48
+        # to align with our build instructions.
+        self.folders.generators = 'build/generators'
+
+    generators = 'CMakeDeps'
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables['tests'] = self.options.tests
+        tc.variables['assert'] = self.options.assertions
+        tc.variables['coverage'] = self.options.coverage
+        tc.variables['jemalloc'] = self.options.jemalloc
+        tc.variables['rocksdb'] = self.options.rocksdb
+        tc.variables['BUILD_SHARED_LIBS'] = self.options.shared
+        tc.variables['static'] = self.options.static
+        tc.variables['unity'] = self.options.unity
+        tc.variables['xrpld'] = self.options.xrpld
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.verbose = True
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.verbose = True
+        cmake.install()
+
+    def package_info(self):
+        libxrpl = self.cpp_info.components['libxrpl']
+        libxrpl.libs = [
+            'xrpl',
+            'xrpl.libpb',
+            'ed25519',
+            'secp256k1',
+        ]
+        # TODO: Fix the protobufs to include each other relative to
+        # `include/`, not `include/ripple/proto/`.
+        libxrpl.includedirs = ['include', 'include/ripple/proto']
+        libxrpl.requires = [
+            'boost::boost',
+            'date::date',
+            'grpc::grpc++',
+            'libarchive::libarchive',
+            'lz4::lz4',
+            'nudb::nudb',
+            'openssl::crypto',
+            'protobuf::libprotobuf',
+            'soci::soci',
+            'sqlite3::sqlite',
+            'xxhash::xxhash',
+            'zlib::zlib',
+        ]
+        if self.options.rocksdb:
+            libxrpl.requires.append('rocksdb::librocksdb')

docs/0001-negative-unl/README.md

@@ -0,0 +1,597 @@
+# Negative UNL Engineering Spec
+
+## The Problem Statement
+
+The moment-to-moment health of the XRP Ledger network depends on the health and
+connectivity of a small number of computers (nodes). The most important nodes
+are validators, specifically ones listed on the unique node list
+([UNL](#Question-What-are-UNLs)). Ripple publishes a recommended UNL that most
+network nodes use to determine which peers in the network are trusted. Although
+most validators use the same list, they are not required to. The XRP Ledger
+network progresses to the next ledger when enough validators reach agreement
+(above the minimum quorum of 80%) about what transactions to include in the next
+ledger.
+
+As an example, if there are 10 validators on the UNL, at least 8 validators have
+to agree with the latest ledger for it to become validated. But what if enough
+of those validators are offline to drop the network below the 80% quorum? The
+XRP Ledger network favors safety/correctness over advancing the ledger. Which
+means if enough validators are offline, the network will not be able to validate
+ledgers.
+
+Unfortunately validators can go offline at any time for many different reasons.
+Power outages, network connectivity issues, and hardware failures are just a few
+scenarios where a validator would appear "offline". Given that most of these
+events are temporary, it would make sense to temporarily remove that validator
+from the UNL. But the UNL is updated infrequently and not every node uses the
+same UNL. So instead of removing the unreliable validator from the Ripple
+recommended UNL, we can create a second negative UNL which is stored directly on
+the ledger (so the entire network has the same view). This will help the network
+see which validators are **currently** unreliable, and adjust their quorum
+calculation accordingly.
+
+*Improving the liveness of the network is the main motivation for the negative UNL.*
+
+### Targeted Faults
+
+In order to determine which validators are unreliable, we need clearly define
+what kind of faults to measure and analyze. We want to deal with the faults we
+frequently observe in the production network. Hence we will only monitor for
+validators that do not reliably respond to network messages or send out
+validations disagreeing with the locally generated validations. We will not
+target other byzantine faults.
+
+To track whether or not a validator is responding to the network, we could
+monitor them with a “heartbeat” protocol. Instead of creating a new heartbeat
+protocol, we can leverage some existing protocol messages to mimic the
+heartbeat. We picked validation messages because validators should send one and
+only one validation message per ledger. In addition, we only count the
+validation messages that agree with the local node's validations.
+
+With the negative UNL, the network could keep making forward progress safely
+even if the number of remaining validators gets to 60%. Say we have a network
+with 10 validators on the UNL and everything is operating correctly. The quorum
+required for this network would be 8 (80% of 10). When validators fail, the
+quorum required would be as low as 6 (60% of 10), which is the absolute
+***minimum quorum***. We need the absolute minimum quorum to be strictly greater
+than 50% of the original UNL so that there cannot be two partitions of
+well-behaved nodes headed in different directions. We arbitrarily choose 60% as
+the minimum quorum to give a margin of safety.
+
+Consider these events in the absence of negative UNL:
+1. 1:00pm - validator1 fails, votes vs. quorum: 9 >= 8, we have quorum
+1. 3:00pm - validator2 fails, votes vs. quorum: 8 >= 8, we have quorum
+1. 5:00pm - validator3 fails, votes vs. quorum: 7 < 8, we don’t have quorum
+    * **network cannot validate new ledgers with 3 failed validators**
+
+We're below 80% agreement, so new ledgers cannot be validated. This is how the
+XRP Ledger operates today, but if the negative UNL was enabled, the events would
+happen as follows. (Please note that the events below are from a simplified
+version of our protocol.)
+
+1. 1:00pm - validator1 fails, votes vs. quorum: 9 >= 8, we have quorum
+1. 1:40pm - network adds validator1 to negative UNL, quorum changes to ceil(9 * 0.8), or 8
+1. 3:00pm - validator2 fails, votes vs. quorum: 8 >= 8, we have quorum
+1. 3:40pm - network adds validator2 to negative UNL, quorum changes to ceil(8 * 0.8), or 7
+1. 5:00pm - validator3 fails, votes vs. quorum: 7 >= 7, we have quorum
+1. 5:40pm - network adds validator3 to negative UNL, quorum changes to ceil(7 * 0.8), or 6
+1. 7:00pm - validator4 fails, votes vs. quorum: 6 >= 6, we have quorum
+    * **network can still validate new ledgers with 4 failed validators**
+
+## External Interactions
+
+### Message Format Changes
+This proposal will:
+1. add a new pseudo-transaction type
+1. add the negative UNL to the ledger data structure.
+
+Any tools or systems that rely on the format of this data will have to be
+updated.
+
+### Amendment
+This feature **will** need an amendment to activate.
+
+## Design
+
+This section discusses the following topics about the Negative UNL design:
+
+* [Negative UNL protocol overview](#Negative-UNL-Protocol-Overview)
+* [Validator reliability measurement](#Validator-Reliability-Measurement)
+* [Format Changes](#Format-Changes)
+* [Negative UNL maintenance](#Negative-UNL-Maintenance)
+* [Quorum size calculation](#Quorum-Size-Calculation)
+* [Filter validation messages](#Filter-Validation-Messages)
+* [High level sequence diagram of code
+  changes](#High-Level-Sequence-Diagram-of-Code-Changes)
+
+### Negative UNL Protocol Overview
+
+Every ledger stores a list of zero or more unreliable validators. Updates to the
+list must be approved by the validators using the consensus mechanism that
+validators use to agree on the set of transactions. The list is used only when
+checking if a ledger is fully validated. If a validator V is in the list, nodes
+with V in their UNL adjust the quorum and V’s validation message is not counted
+when verifying if a ledger is fully validated. V’s flow of messages and network
+interactions, however, will remain the same.
+
+We define the ***effective UNL** = original UNL - negative UNL*, and the
+***effective quorum*** as the quorum of the *effective UNL*. And we set
+*effective quorum = Ceiling(80% * effective UNL)*.
+
+### Validator Reliability Measurement
+
+A node only measures the reliability of validators on its own UNL, and only
+proposes based on local observations. There are many metrics that a node can
+measure about its validators, but we have chosen ledger validation messages.
+This is because every validator shall send one and only one signed validation
+message per ledger. This keeps the measurement simple and removes
+timing/clock-sync issues. A node will measure the percentage of agreeing
+validation messages (*PAV*) received from each validator on the node's UNL. Note
+that the node will only count the validation messages that agree with its own
+validations.
+
+We define the **PAV** as the **P**ercentage of **A**greed **V**alidation
+messages received for the last N ledgers, where N = 256 by default.
+
+When the PAV drops below the ***low-water mark***, the validator is considered
+unreliable, and is a candidate to be disabled by being added to the negative
+UNL. A validator must have a PAV higher than the ***high-water mark*** to be
+re-enabled. The validator is re-enabled by removing it from the negative UNL. In
+the implementation, we plan to set the low-water mark as 50% and the high-water
+mark as 80%.
+
+### Format Changes
+
+The negative UNL component in a ledger contains three fields.
+* ***NegativeUNL***: The current negative UNL, a list of unreliable validators.
+* ***ToDisable***: The validator to be added to the negative UNL on the next
+  flag ledger.
+* ***ToReEnable***: The validator to be removed from the negative UNL on the
+  next flag ledger.
+
+All three fields are optional. When the *ToReEnable* field exists, the
+*NegativeUNL* field cannot be empty.
+
+A new pseudo-transaction, ***UNLModify***, is added. It has three fields
+* ***Disabling***: A flag indicating whether the modification is to disable or
+  to re-enable a validator.
+* ***Seq***: The ledger sequence number.
+* ***Validator***: The validator to be disabled or re-enabled.
+
+There would be at most one *disable* `UNLModify` and one *re-enable* `UNLModify`
+transaction per flag ledger. The full machinery is described further on.
+
+### Negative UNL Maintenance
+
+The negative UNL can only be modified on the flag ledgers. If a validator's
+reliability status changes, it takes two flag ledgers to modify the negative
+UNL. Let's see an example of the algorithm:
+
+* Ledger seq = 100: A validator V goes offline.
+* Ledger seq = 256: This is a flag ledger, and V's reliability measurement *PAV*
+  is lower than the low-water mark. Other validators add `UNLModify`
+  pseudo-transactions `{true, 256, V}` to the transaction set which goes through
+  the consensus. Then the pseudo-transaction is applied to the negative UNL
+  ledger component by setting `ToDisable = V`.
+* Ledger seq = 257 ~ 511: The negative UNL ledger component is copied from the
+  parent ledger.
+* Ledger seq=512: This is a flag ledger, and the negative UNL is updated
+  `NegativeUNL = NegativeUNL + ToDisable`.
+
+The negative UNL may have up to `MaxNegativeListed = floor(original UNL * 25%)`
+validators. The 25% is because of 75% * 80% = 60%, where 75% = 100% - 25%, 80%
+is the quorum of the effective UNL, and 60% is the absolute minimum quorum of
+the original UNL. Adding more than 25% validators to the negative UNL does not
+improve the liveness of the network, because adding more validators to the
+negative UNL cannot lower the effective quorum.
+
+The following is the detailed algorithm:
+
+* **If** the ledger seq = x is a flag ledger
+
+    1. Compute `NegativeUNL = NegativeUNL + ToDisable - ToReEnable` if they
+    exist in the parent ledger
+
+		1. Try to find a candidate to disable if `sizeof NegativeUNL < MaxNegativeListed`
+
+		1. Find a validator V that has a *PAV* lower than the low-water
+		mark, but is not in `NegativeUNL`.
+
+        1. If two or more are found, their public keys are XORed with the hash
+        of the parent ledger and the one with the lowest XOR result is chosen.
+				
+        1. If V is found, create a `UNLModify` pseudo-transaction
+        `TxDisableValidator = {true, x, V}`
+				
+    1. Try to find a candidate to re-enable if `sizeof NegativeUNL > 0`:
+		
+        1. Find a validator U that is in `NegativeUNL` and has a *PAV* higher
+        than the high-water mark.
+				
+        1. If U is not found, try to find one in `NegativeUNL` but not in the
+        local *UNL*.
+				
+        1. If two or more are found, their public keys are XORed with the hash
+        of the parent ledger and the one with the lowest XOR result is chosen.
+				
+        1. If U is found, create a `UNLModify` pseudo-transaction
+        `TxReEnableValidator = {false, x, U}`
+				
+    1. If any `UNLModify` pseudo-transactions are created, add them to the
+    transaction set. The transaction set goes through the consensus algorithm.
+		
+    1. If have enough support, the `UNLModify` pseudo-transactions remain in the
+    transaction set agreed by the validators. Then the pseudo-transactions are
+    applied to the ledger:
+		
+        1. If have `TxDisableValidator`, set `ToDisable=TxDisableValidator.V`.
+        Else clear `ToDisable`.
+				
+        1. If have `TxReEnableValidator`, set
+        `ToReEnable=TxReEnableValidator.U`. Else clear `ToReEnable`.
+				
+* **Else** (not a flag ledger)
+
+    1. Copy the negative UNL ledger component from the parent ledger
+
+The negative UNL is stored on each ledger because we don't know when a validator
+may reconnect to the network. If the negative UNL was stored only on every flag
+ledger, then a new validator would have to wait until it acquires the latest
+flag ledger to know the negative UNL. So any new ledgers created that are not
+flag ledgers copy the negative UNL from the parent ledger.
+
+Note that when we have a validator to disable and a validator to re-enable at
+the same flag ledger, we create two separate `UNLModify` pseudo-transactions. We
+want either one or the other or both to make it into the ledger on their own
+merits.
+
+Readers may have noticed that we defined several rules of creating the
+`UNLModify` pseudo-transactions but did not describe how to enforce the rules.
+The rules are actually enforced by the existing consensus algorithm. Unless
+enough validators propose the same pseudo-transaction it will not be included in
+the transaction set of the ledger.
+
+### Quorum Size Calculation
+
+The effective quorum is 80% of the effective UNL. Note that because at most 25%
+of the original UNL can be on the negative UNL, the quorum should not be lower
+than the absolute minimum quorum (i.e. 60%) of the original UNL. However,
+considering that different nodes may have different UNLs, to be safe we compute
+`quorum = Ceiling(max(60% * original UNL, 80% * effective UNL))`.
+
+### Filter Validation Messages
+
+If a validator V is in the negative UNL, it still participates in consensus
+sessions in the same way, i.e. V still follows the protocol and publishes
+proposal and validation messages. The messages from V are still stored the same
+way by everyone, used to calculate the new PAV for V, and could be used in
+future consensus sessions if needed. However V's ledger validation message is
+not counted when checking if the ledger is fully validated.
+
+### High Level Sequence Diagram of Code Changes
+
+The diagram below is the sequence of one round of consensus. Classes and
+components with non-trivial changes are colored green.
+
+* The `ValidatorList` class is modified to compute the quorum of the effective
+  UNL.
+
+* The `Validations` class provides an interface for querying the validation
+  messages from trusted validators.
+
+* The `ConsensusAdaptor` component:
+
+    * The `RCLConsensus::Adaptor` class is modified for creating `UNLModify`
+      Pseudo-Transactions.
+		
+    * The `Change` class is modified for applying `UNLModify`
+      Pseudo-Transactions.
+		
+    * The `Ledger` class is modified for creating and adjusting the negative UNL
+      ledger component.
+		
+    * The `LedgerMaster` class is modified for filtering out validation messages
+      from negative UNL validators when verifying if a ledger is fully
+      validated.
+
+![Sequence diagram](./negativeUNL_highLevel_sequence.png?raw=true "Negative UNL
+ Changes")
+
+
+## Roads Not Taken
+
+### Use a Mechanism Like Fee Voting to Process UNLModify Pseudo-Transactions
+
+The previous version of the negative UNL specification used the same mechanism
+as the [fee voting](https://xrpl.org/fee-voting.html#voting-process.) for
+creating the negative UNL, and used the negative UNL as soon as the ledger was
+fully validated. However the timing of fully validation can differ among nodes,
+so different negative UNLs could be used, resulting in different effective UNLs
+and different quorums for the same ledger. As a result, the network's safety is
+impacted.
+
+This updated version does not impact safety though operates a bit more slowly.
+The negative UNL modifications in the *UNLModify* pseudo-transaction approved by
+the consensus will take effect at the next flag ledger. The extra time of the
+256 ledgers should be enough for nodes to be in sync of the negative UNL
+modifications.
+
+### Use an Expiration Approach to Re-enable Validators
+
+After a validator disabled by the negative UNL becomes reliable, other
+validators explicitly vote for re-enabling it. An alternative approach to
+re-enable a validator is the expiration approach, which was considered in the
+previous version of the specification. In the expiration approach, every entry
+in the negative UNL has a fixed expiration time. One flag ledger interval was
+chosen as the expiration interval. Once expired, the other validators must
+continue voting to keep the unreliable validator on the negative UNL. The
+advantage of this approach is its simplicity. But it has a requirement. The
+negative UNL protocol must be able to vote multiple unreliable validators to be
+disabled at the same flag ledger. In this version of the specification, however,
+only one unreliable validator can be disabled at a flag ledger. So the
+expiration approach cannot be simply applied.
+
+### Validator Reliability Measurement and Flag Ledger Frequency
+
+If the ledger time is about 4.5 seconds and the low-water mark is 50%, then in
+the worst case, it takes 48 minutes *((0.5 * 256 + 256 + 256) * 4.5 / 60 = 48)*
+to put an offline validator on the negative UNL. We considered lowering the flag
+ledger frequency so that the negative UNL can be more responsive. We also
+considered decoupling the reliability measurement and flag ledger frequency to
+be more flexible. In practice, however, their benefits are not clear.
+
+
+## New Attack Vectors
+
+A group of malicious validators may try to frame a reliable validator and put it
+on the negative UNL. But they cannot succeed. Because:
+
+1. A reliable validator sends a signed validation message every ledger. A
+sufficient peer-to-peer network will propagate the validation messages to other
+validators. The validators will decide if another validator is reliable or not
+only by its local observation of the validation messages received. So an honest
+validator’s vote on another validator’s reliability is accurate.
+
+1. Given the votes are accurate, and one vote per validator, an honest validator
+will not create a UNLModify transaction of a reliable validator.
+
+1. A validator can be added to a negative UNL only through a UNLModify
+transaction.
+
+Assuming the group of malicious validators is less than the quorum, they cannot
+frame a reliable validator.
+
+## Summary
+
+The bullet points below briefly summarize the current proposal:
+
+* The motivation of the negative UNL is to improve the liveness of the network.
+
+* The targeted faults are the ones frequently observed in the production
+  network.
+
+* Validators propose negative UNL candidates based on their local measurements.
+
+* The absolute minimum quorum is 60% of the original UNL.
+
+* The format of the ledger is changed, and a new *UNLModify* pseudo-transaction
+  is added. Any tools or systems that rely on the format of these data will have
+  to be updated.
+
+* The negative UNL can only be modified on the flag ledgers.
+
+* At most one validator can be added to the negative UNL at a flag ledger.
+
+* At most one validator can be removed from the negative UNL at a flag ledger.
+
+* If a validator's reliability status changes, it takes two flag ledgers to
+  modify the negative UNL.
+
+* The quorum is the larger of 80% of the effective UNL and 60% of the original
+  UNL.
+
+* If a validator is on the negative UNL, its validation messages are ignored
+  when the local node verifies if a ledger is fully validated.
+
+## FAQ
+
+### Question: What are UNLs?
+
+Quote from the [Technical FAQ](https://xrpl.org/technical-faq.html): "They are
+the lists of transaction validators a given participant believes will not
+conspire to defraud them."
+
+### Question: How does the negative UNL proposal affect network liveness?
+
+The network can make forward progress when more than a quorum of the trusted
+validators agree with the progress. The lower the quorum size is, the easier for
+the network to progress. If the quorum is too low, however, the network is not
+safe because nodes may have different results. So the quorum size used in the
+consensus protocol is a balance between the safety and the liveness of the
+network. The negative UNL reduces the size of the effective UNL, resulting in a
+lower quorum size while keeping the network safe.
+
+<h3> Question: How does a validator get into the negative UNL? How is a
+validator removed from the negative UNL? </h3>
+
+A validator’s reliability is measured by other validators. If a validator
+becomes unreliable, at a flag ledger, other validators propose *UNLModify*
+pseudo-transactions which vote the validator to add to the negative UNL during
+the consensus session. If agreed, the validator is added to the negative UNL at
+the next flag ledger. The mechanism of removing a validator from the negative
+UNL is the same.
+
+### Question: Given a negative UNL, what happens if the UNL changes?
+
+Answer: Let’s consider the cases: 
+
+1. A validator is added to the UNL, and it is already in the negative UNL. This
+case could happen when not all the nodes have the same UNL. Note that the
+negative UNL on the ledger lists unreliable nodes that are not necessarily the
+validators for everyone.
+
+    In this case, the liveness is affected negatively. Because the minimum
+    quorum could be larger but the usable validators are not increased.
+
+1. A validator is removed from the UNL, and it is in the negative UNL.
+
+    In this case, the liveness is affected positively. Because the quorum could
+    be smaller but the usable validators are not reduced.
+
+1. A validator is added to the UNL, and it is not in the negative UNL.
+1. A validator is removed from the UNL, and it is not in the negative UNL.
+	
+    Case 3 and 4 are not affected by the negative UNL protocol.
+
+### Question: Can we simply lower the quorum to 60% without the negative UNL? 
+
+Answer: No, because the negative UNL approach is safer.
+
+First let’s compare the two approaches intuitively, (1) the *negative UNL*
+approach, and (2) *lower quorum*: simply lowering the quorum from 80% to 60%
+without the negative UNL. The negative UNL approach uses consensus to come up
+with a list of unreliable validators, which are then removed from the effective
+UNL temporarily. With this approach, the list of unreliable validators is agreed
+to by a quorum of validators and will be used by every node in the network to
+adjust its UNL. The quorum is always 80% of the effective UNL. The lower quorum
+approach is a tradeoff between safety and liveness and against our principle of
+preferring safety over liveness. Note that different validators don't have to
+agree on which validation sources they are ignoring.
+
+Next we compare the two approaches quantitatively with examples, and apply
+Theorem 8 of [Analysis of the XRP Ledger Consensus
+Protocol](https://arxiv.org/abs/1802.07242) paper:
+
+*XRP LCP guarantees fork safety if **O<sub>i,j</sub> > n<sub>j</sub> / 2 +
+n<sub>i</sub> − q<sub>i</sub> + t<sub>i,j</sub>** for every pair of nodes
+P<sub>i</sub>, P<sub>j</sub>,*
+
+where *O<sub>i,j</sub>* is the overlapping requirement, n<sub>j</sub> and
+n<sub>i</sub> are UNL sizes, q<sub>i</sub> is the quorum size of P<sub>i</sub>,
+*t<sub>i,j</sub> = min(t<sub>i</sub>, t<sub>j</sub>, O<sub>i,j</sub>)*, and
+t<sub>i</sub> and t<sub>j</sub> are the number of faults can be tolerated by
+P<sub>i</sub> and P<sub>j</sub>.
+
+We denote *UNL<sub>i</sub>* as *P<sub>i</sub>'s UNL*, and *|UNL<sub>i</sub>|* as
+the size of *P<sub>i</sub>'s UNL*.
+
+Assuming *|UNL<sub>i</sub>| = |UNL<sub>j</sub>|*, let's consider the following
+three cases:
+
+1. With 80% quorum and 20% faults, *O<sub>i,j</sub> > 100% / 2 + 100% - 80% +
+20% = 90%*. I.e. fork safety requires > 90% UNL overlaps. This is one of the
+results in the analysis paper.
+
+1. If the quorum is 60%, the relationship between the overlapping requirement
+and the faults that can be tolerated is *O<sub>i,j</sub> > 90% +
+t<sub>i,j</sub>*. Under the same overlapping condition (i.e. 90%), to guarantee
+the fork safety, the network cannot tolerate any faults. So under the same
+overlapping condition, if the quorum is simply lowered, the network can tolerate
+fewer faults.
+
+1. With the negative UNL approach, we want to argue that the inequation
+*O<sub>i,j</sub> > n<sub>j</sub> / 2 + n<sub>i</sub> − q<sub>i</sub> +
+t<sub>i,j</sub>* is always true to guarantee fork safety, while the negative UNL
+protocol runs, i.e. the effective quorum is lowered without weakening the
+network's fault tolerance. To make the discussion easier, we rewrite the
+inequation as *O<sub>i,j</sub> > n<sub>j</sub> / 2 + (n<sub>i</sub> −
+q<sub>i</sub>) + min(t<sub>i</sub>, t<sub>j</sub>)*, where O<sub>i,j</sub> is
+dropped from the definition of t<sub>i,j</sub> because *O<sub>i,j</sub> >
+min(t<sub>i</sub>, t<sub>j</sub>)* always holds under the parameters we will
+use. Assuming a validator V is added to the negative UNL, now let's consider the
+4 cases:
+
+    1. V is not on UNL<sub>i</sub> nor UNL<sub>j</sub>
+
+        The inequation holds because none of the variables change.
+
+    1. V is on UNL<sub>i</sub> but not on UNL<sub>j</sub>
+
+        The value of *(n<sub>i</sub> − q<sub>i</sub>)* is smaller. The value of
+        *min(t<sub>i</sub>, t<sub>j</sub>)* could be smaller too. Other
+        variables do not change. Overall, the left side of the inequation does
+        not change, but the right side is smaller. So the inequation holds.
+    
+    1. V is not on UNL<sub>i</sub> but on UNL<sub>j</sub>
+
+        The value of *n<sub>j</sub> / 2* is smaller. The value of
+        *min(t<sub>i</sub>, t<sub>j</sub>)* could be smaller too. Other
+        variables do not change. Overall, the left side of the inequation does
+        not change, but the right side is smaller. So the inequation holds.
+    
+    1. V is on both UNL<sub>i</sub> and UNL<sub>j</sub>
+
+        The value of *O<sub>i,j</sub>* is reduced by 1. The values of
+        *n<sub>j</sub> / 2*, *(n<sub>i</sub> − q<sub>i</sub>)*, and
+        *min(t<sub>i</sub>, t<sub>j</sub>)* are reduced by 0.5, 0.2, and 1
+        respectively. The right side is reduced by 1.7. Overall, the left side
+        of the inequation is reduced by 1, and the right side is reduced by 1.7.
+        So the inequation holds.
+
+    The inequation holds for all the cases. So with the negative UNL approach,
+    the network's fork safety is preserved, while the quorum is lowered that
+    increases the network's liveness.
+
+<h3> Question: We have observed that occasionally a validator wanders off on its
+own chain. How is this case handled by the negative UNL algorithm? </h3>
+
+Answer: The case that a validator wanders off on its own chain can be measured
+with the validations agreement. Because the validations by this validator must
+be different from other validators' validations of the same sequence numbers.
+When there are enough disagreed validations, other validators will vote this
+validator onto the negative UNL.
+
+In general by measuring the agreement of validations, we also measured the
+"sanity". If two validators have too many disagreements, one of them could be
+insane. When enough validators think a validator is insane, that validator is
+put on the negative UNL.
+
+<h3> Question: Why would there be at most one disable UNLModify and one
+re-enable UNLModify transaction per flag ledger? </h3>
+
+Answer: It is a design choice so that the effective UNL does not change too
+quickly. A typical targeted scenario is several validators go offline slowly
+during a long weekend. The current design can handle this kind of cases well
+without changing the effective UNL too quickly.
+
+## Appendix
+
+### Confidence Test
+
+We will use two test networks, a single machine test network with multiple IP
+addresses and the QE test network with multiple machines. The single machine
+network will be used to test all the test cases and to debug. The QE network
+will be used after that. We want to see the test cases still pass with real
+network delay. A test case specifies:
+
+1. a UNL with different number of validators for different test cases,
+1. a network with zero or more non-validator nodes, 
+1. a sequence of validator reliability change events (by killing/restarting
+   nodes, or by running modified rippled that does not send all validation
+   messages),
+1. the correct outcomes. 
+
+For all the test cases, the correct outcomes are verified by examining logs. We
+will grep the log to see if the correct negative UNLs are generated, and whether
+or not the network is making progress when it should be. The ripdtop tool will
+be helpful for monitoring validators' states and ledger progress. Some of the
+timing parameters of rippled will be changed to have faster ledger time. Most if
+not all test cases do not need client transactions.
+
+For example, the test cases for the prototype:
+1. A 10-validator UNL.
+1. The network does not have other nodes.
+1. The validators will be started from the genesis. Once they start to produce
+   ledgers, we kill five validators, one every flag ledger interval. Then we
+   will restart them one by one.
+1. A sequence of events (or the lack of events) such as a killed validator is
+   added to the negative UNL.
+
+#### Roads Not Taken: Test with Extended CSF 
+
+We considered testing with the current unit test framework, specifically the
+[Consensus Simulation
+Framework](https://github.com/ripple/rippled/blob/develop/src/test/csf/README.md)
+(CSF). However, the CSF currently can only test the generic consensus algorithm
+as in the paper: [Analysis of the XRP Ledger Consensus
+Protocol](https://arxiv.org/abs/1802.07242).

docs/0001-negative-unl/negativeUNLSqDiagram.puml

@@ -0,0 +1,79 @@
+@startuml negativeUNL_highLevel_sequence
+
+skinparam sequenceArrowThickness 2
+skinparam roundcorner 20
+skinparam maxmessagesize 160
+
+actor "Rippled Start" as RS
+participant "Timer" as T 
+participant "NetworkOPs" as NOP 
+participant "ValidatorList" as VL #lightgreen
+participant "Consensus" as GC
+participant "ConsensusAdaptor" as CA #lightgreen
+participant "Validations" as RM #lightgreen
+
+RS -> NOP: begin consensus
+activate NOP
+NOP -[#green]> VL: <font color=green>update negative UNL
+hnote over VL#lightgreen: store a copy of\nnegative UNL
+VL -> NOP
+NOP -> VL: update trusted validators
+activate VL
+VL -> VL: re-calculate quorum
+hnote over VL#lightgreen: ignore negative listed validators\nwhen calculate quorum 
+VL -> NOP
+deactivate VL
+NOP -> GC: start round
+activate GC
+GC -> GC: phase = OPEN
+GC -> NOP
+deactivate GC
+deactivate NOP
+
+loop at regular frequency
+T -> GC: timerEntry
+activate GC
+end
+
+alt phase == OPEN
+    alt should close ledger 
+        GC -> GC: phase = ESTABLISH
+        GC -> CA: onClose
+        activate CA
+            alt sqn%256==0 
+            CA -[#green]> RM: <font color=green>getValidations
+            CA -[#green]> CA: <font color=green>create UNLModify Tx 
+            hnote over CA#lightgreen: use validatations of the last 256 ledgers\nto figure out UNLModify Tx candidates.\nIf any, create UNLModify Tx, and add to TxSet.               
+            end
+        CA -> GC
+        GC -> CA: propose
+        deactivate CA
+    end
+else phase == ESTABLISH
+    hnote over GC: receive peer postions
+    GC -> GC : update our position
+    GC -> CA : propose \n(if position changed)
+    GC -> GC : check if have consensus
+    alt consensus reached
+        GC -> GC: phase = ACCEPT
+        GC -> CA : onAccept
+        activate CA
+            CA -> CA : build LCL
+            hnote over CA #lightgreen: copy negative UNL from parent ledger
+            alt sqn%256==0
+                CA -[#green]> CA: <font color=green>Adjust negative UNL 
+                CA -[#green]> CA: <font color=green>apply UNLModify Tx
+            end
+            CA -> CA : validate and send validation message
+            activate NOP
+                CA -> NOP : end consensus and\n<b>begin next consensus round
+            deactivate NOP
+        deactivate CA        
+        hnote over RM: receive validations
+    end
+else phase == ACCEPTED
+    hnote over GC: timerEntry hash nothing to do at this phase
+end
+deactivate GC
+
+@enduml

docs/0010-ledger-replay/README.md

@@ -0,0 +1,88 @@
+# Ledger Replay
+
+`LedgerReplayer` is a new `Stoppable` for replaying ledgers.
+Patterned after two other `Stoppable`s under `JobQueue`---`InboundLedgers`
+and `InboundTransactions`---it acts like a factory for creating
+state-machine workers, and a network message demultiplexer for those workers.
+Think of these workers like asynchronous functions.
+Like functions, they each take a set of parameters.
+The `Stoppable` memoizes these functions. It maintains a table for each
+worker type, mapping sets of arguments to the worker currently working
+on that argument set.
+Whenever the `Stoppable` is asked to construct a worker, it first searches its
+table to see if there is an existing worker with the same or overlapping
+argument set.
+If one exists, then it is used. If not, then a new one is created,
+initialized, and added to the table.
+
+For `LedgerReplayer`, there are three worker types: `LedgerReplayTask`,
+`SkipListAcquire`, and `LedgerDeltaAcquire`.
+Each is derived from `TimeoutCounter` to give it a timeout.
+For `LedgerReplayTask`, the parameter set
+is {reason, finish ledger ID, number of ledgers}. For `SkipListAcquire` and
+`LedgerDeltaAcquire`, there is just one parameter: a ledger ID.
+
+Each `Stoppable` has an entry point. For `LedgerReplayer`, it is `replay`.
+`replay` creates two workers: a `LedgerReplayTask` and a `SkipListAcquire`.
+`LedgerDeltaAcquire`s are created in the callback for when the skip list
+returns.
+
+For `SkipListAcquire` and `LedgerDeltaAcquire`, initialization fires off the
+underlying asynchronous network request and starts the timeout. The argument
+set identifying the worker is included in the network request, and copied to
+the network response. `SkipListAcquire` sends a request for a proof path for
+the skip list of the desired ledger. `LedgerDeltaAcquire` sends a request for
+the transaction set of the desired ledger.
+
+`LedgerReplayer` is also a network message demultiplexer.
+When a response arrives for a request that was sent by a `SkipListAcquire` or
+`LedgerDeltaAcquire` worker, the `Peer` object knows to send it to the
+`LedgerReplayer`, which looks up the worker waiting for that response based on
+the identifying argument set included in the response.
+
+`LedgerReplayTask` may ask `InboundLedgers` to send requests to acquire
+the start ledger, but there is no way to attach a callback or be notified when
+the `InboundLedger` worker completes. All the responses for its messages will
+be directed to `InboundLedgers`, not `LedgerReplayer`. Instead,
+`LedgerReplayTask` checks whether the start ledger has arrived every time its
+timeout expires.
+
+Like a promise, each worker keeps track of whether it is pending (`!isDone()`)
+or whether it has resolved successfully (`complete_ == true`) or unsuccessfully
+(`failed_ == true`). It will never exist in both resolved states at once, nor
+will it return to a pending state after reaching a resolved state.
+
+Like promises, some workers can accept continuations to be called when they
+reach a resolved state, or immediately if they are already resolved.
+`SkipListAcquire` and `LedgerDeltaAcquire` both accept continuations of a type
+specific to their payload, both via a method named `addDataCallback()`. Continuations
+cannot be removed explicitly, but they are held by `std::weak_ptr` so they can
+be removed implicitly.
+
+`LedgerReplayTask` is simultaneously:
+
+1. an asynchronous function,
+1. a continuation to one `SkipListAcquire` asynchronous function,
+1. a continuation to zero or more `LedgerDeltaAcquire` asynchronous functions, and
+1. a continuation to its own timeout.
+
+Each of these roles corresponds to different entry points:
+
+1. `init()`
+1. the callback added to `SkipListAcquire`, which calls `updateSkipList(...)` or `cancel()`
+1. the callback added to `LedgerDeltaAcquire`, which calls `deltaReady(...)` or `cancel()`
+1. `onTimer()`
+
+Each of these entry points does something unique to that entry point. They
+either (a) transition `LedgerReplayTask` to a terminal failed resolved state
+(`cancel()` and `onTimer()`) or (b) try to make progress toward the successful
+resolved state. `init()` and `updateSkipList(...)` call `trigger()` while
+`deltaReady(...)` calls `tryAdvance()`. There's a similarity between this
+pattern and the way coroutines are implemented, where every yield saves the spot
+in the code where it left off and every resume jumps back to that spot.
+
+### Sequence Diagram
+![Sequence diagram](./ledger_replay_sequence.png?raw=true "A successful ledger replay")
+
+### Class Diagram
+![Class diagram](./ledger_replay_classes.png?raw=true "Ledger replay classes")

docs/0010-ledger-replay/ledger_replay_classes.puml

@@ -0,0 +1,98 @@
+@startuml
+
+class TimeoutCounter {
+  #app_ : Application&
+}
+
+TimeoutCounter o-- "1" Application 
+': app_
+
+Stoppable <.. Application
+
+class Application {
+  -m_ledgerReplayer : uptr<LedgerReplayer>
+  -m_inboundLedgers : uptr<InboundLedgers>
+}
+
+Application *-- "1" LedgerReplayer 
+': m_ledgerReplayer
+Application *-- "1" InboundLedgers 
+': m_inboundLedgers
+
+Stoppable <.. InboundLedgers
+Application "1" --o InboundLedgers 
+': app_
+
+class InboundLedgers {
+  -app_ : Application&
+}
+
+Stoppable <.. LedgerReplayer
+InboundLedgers "1" --o LedgerReplayer 
+': inboundLedgers_
+Application "1" --o LedgerReplayer 
+': app_
+
+class LedgerReplayer {
+  +createDeltas(LedgerReplayTask)
+  -app_ : Application&
+  -inboundLedgers_ : InboundLedgers&
+  -tasks_ : vector<sptr<LedgerReplayTask>>
+  -deltas_ : hash_map<u256, wptr<LedgerDeltaAcquire>>
+  -skipLists_ : hash_map<u256, wptr<SkipListAcquire>>
+}
+
+LedgerReplayer *-- LedgerReplayTask 
+': tasks_
+LedgerReplayer o-- LedgerDeltaAcquire 
+': deltas_
+LedgerReplayer o-- SkipListAcquire 
+': skipLists_
+
+TimeoutCounter <.. LedgerReplayTask
+InboundLedgers "1" --o LedgerReplayTask 
+': inboundLedgers_
+LedgerReplayer "1" --o LedgerReplayTask 
+': replayer_
+
+class LedgerReplayTask {
+  -inboundLedgers_ : InboundLedgers&
+  -replayer_ : LedgerReplayer&
+  -skipListAcquirer_ : sptr<SkipListAcquire>
+  -deltas_ : vector<sptr<LedgerDeltaAcquire>>
+  +addDelta(sptr<LedgerDeltaAcquire>)
+}
+
+LedgerReplayTask *-- "1" SkipListAcquire 
+': skipListAcquirer_
+LedgerReplayTask *-- LedgerDeltaAcquire 
+': deltas_
+
+TimeoutCounter <.. SkipListAcquire
+InboundLedgers "1" --o SkipListAcquire 
+': inboundLedgers_
+LedgerReplayer "1" --o SkipListAcquire 
+': replayer_
+LedgerReplayTask --o SkipListAcquire : implicit via callback
+
+class SkipListAcquire {
+  +addDataCallback(callback)
+  -inboundLedgers_ : InboundLedgers&
+  -replayer_ : LedgerReplayer&
+  -dataReadyCallbacks_ : vector<callback>
+}
+
+TimeoutCounter <.. LedgerDeltaAcquire
+InboundLedgers "1" --o LedgerDeltaAcquire 
+': inboundLedgers_
+LedgerReplayer "1" --o LedgerDeltaAcquire 
+': replayer_
+LedgerReplayTask --o LedgerDeltaAcquire : implicit via callback
+
+class LedgerDeltaAcquire {
+  +addDataCallback(callback)
+  -inboundLedgers_ : InboundLedgers&
+  -replayer_ : LedgerReplayer&
+  -dataReadyCallbacks_ : vector<callback>
+}
+@enduml

docs/0010-ledger-replay/ledger_replay_sequence.puml

@@ -0,0 +1,85 @@
+@startuml
+
+autoactivate on
+
+' participant app as "Application"
+participant peer as "Peer"
+participant lr as "LedgerReplayer"
+participant lrt as "LedgerReplayTask"
+participant sla as "SkipListAcquire"
+participant lda as "LedgerDeltaAcquire"
+
+[-> lr : replay(finishId, numLedgers)
+  lr -> sla : make_shared(finishHash)
+  return skipList
+  lr -> lrt : make_shared(skipList)
+  return task
+  lr -> sla : init(numPeers=1)
+    sla -> sla : trigger(numPeers=1)
+      sla -> peer : sendRequest(ProofPathRequest)
+      return
+    return
+  return
+  lr -> lrt : init()
+    lrt -> sla : addDataCallback(callback)
+    return
+  return
+deactivate lr
+
+[-> peer : onMessage(ProofPathResponse)
+  peer -> lr : gotSkipList(ledgerHeader, item)
+    lr -> sla : processData(ledgerSeq, item)
+      sla -> sla : onSkipListAcquired(skipList, ledgerSeq)
+        sla -> sla : notify()
+        note over sla: call the callbacks added by\naddDataCallback(callback).
+          sla -> lrt : callback(ledgerId)
+            lrt -> lrt : updateSkipList(ledgerId, ledgerSeq, skipList)
+            lrt -> lr : createDeltas(this)
+            loop
+              lr -> lda : make_shared(ledgerId, ledgerSeq)
+              return delta
+              lr -> lrt : addDelta(delta)              
+                lrt -> lda : addDataCallback(callback)
+                return
+              return
+              lr -> lda : init(numPeers=1)
+                lda -> lda : trigger(numPeers=1)
+                  lda -> peer : sendRequest(ReplayDeltaRequest)
+                  return
+                return
+              return
+              end
+            return
+          return
+        return
+      return
+    return
+  return
+deactivate peer
+
+[-> peer : onMessage(ReplayDeltaResponse)
+  peer -> lr : gotReplayDelta(ledgerHeader)
+    lr -> lda : processData(ledgerHeader, txns)
+      lda -> lda : notify()
+      note over lda: call the callbacks added by\naddDataCallback(callback).
+        lda -> lrt : callback(ledgerId) 
+        lrt -> lrt : deltaReady(ledgerId)
+          lrt -> lrt : tryAdvance()
+            loop as long as child can be built
+            lrt -> lda : tryBuild(parent)
+              lda -> lda : onLedgerBuilt()
+                note over lda
+                  Schedule a job to store the built ledger.
+                end note
+              return
+            return child
+            end
+          return
+        return
+      return
+    return
+  return
+deactivate peer
+
+
+@enduml

docs/CodingStyle.md

@@ -41,18 +41,16 @@ overlooked. Blank lines are used to separate code into "paragraphs."
 
 * Always place a space before and after all binary operators,
   especially assignments (`operator=`).
-* The `!` operator should always be followed by a space.
+* The `!` operator should be preceded by a space, but not followed by one.
 * The `~` operator should be preceded by a space, but not followed by one.
 * The `++` and `--` operators should have no spaces between the operator and
   the operand.
 * A space never appears before a comma, and always appears after a comma.
-* Always place a space before an opening parenthesis. One exception is if
-  the parentheses are empty.
 * Don't put spaces after a parenthesis. A typical member function call might
   look like this: `foobar (1, 2, 3);`
 * In general, leave a blank line before an `if` statement.
 * In general, leave a blank line after a closing brace `}`.
-* Do not place code or comments on the same line as any opening or
+* Do not place code on the same line as any opening or
   closing brace.
 * Do not write `if` statements all-on-one-line. The exception to this is when
   you've got a sequence of similar `if` statements, and are aligning them all

docs/Docker.md

@@ -1,16 +1,5 @@
-# Rippled Docker Image
+# `rippled` Docker Image
 
-Rippled has a continuous deployment pipeline that turns every git commit into a
-docker image for quick testing and deployment.
-
-To run the tip of the latest release via docker:
-
-```$ docker run -P -v /srv/rippled/ ripple/rippled:latest```
-
-To run the tip of active development:
-
-```$ docker run -P -v /srv/rippled/ ripple/rippled:develop```
-
-Where ```/srv/rippled``` points to a directory containing a rippled.cfg and
-database files. By default, port 5005/tcp maps to the RPC port and 51235/udp to
-the peer port.
+- Some info relating to Docker containers can be found here: [../Builds/containers](../Builds/containers)
+- Images for building and testing rippled can be found here: [thejohnfreeman/rippled-docker](https://github.com/thejohnfreeman/rippled-docker/)
+  - These images do not have rippled. They have all the tools necessary to build rippled.

docs/Dockerfile

@@ -1,31 +0,0 @@
-FROM ubuntu:16.04
-
-RUN apt -y update
-RUN apt -y upgrade
-RUN apt -y install build-essential g++ git libbz2-dev wget python-dev
-RUN apt -y install cmake flex bison graphviz graphviz-dev libicu-dev
-RUN apt -y install jarwrapper java-common
-
-RUN cd /tmp
-ENV CM_INSTALLER=cmake-3.10.0-rc3-Linux-x86_64.sh
-ENV CM_VER_DIR=/opt/local/cmake-3.10.0
-RUN cd /tmp && wget https://cmake.org/files/v3.10/$CM_INSTALLER && chmod a+x $CM_INSTALLER
-RUN mkdir -p $CM_VER_DIR
-RUN ln -s $CM_VER_DIR /opt/local/cmake
-RUN /tmp/$CM_INSTALLER --prefix=$CM_VER_DIR --exclude-subdir
-RUN rm -f /tmp/$CM_INSTALLER
-
-RUN cd /tmp && wget https://ftp.stack.nl/pub/users/dimitri/doxygen-1.8.14.src.tar.gz
-RUN cd /tmp && tar xvf doxygen-1.8.14.src.tar.gz
-RUN mkdir -p /tmp/doxygen-1.8.14/build
-RUN cd /tmp/doxygen-1.8.14/build && /opt/local/cmake/bin/cmake -G "Unix Makefiles" ..
-RUN cd /tmp/doxygen-1.8.14/build && make -j2
-RUN cd /tmp/doxygen-1.8.14/build && make install
-RUN rm -f /tmp/doxygen-1.8.14.src.tar.gz
-RUN rm -rf /tmp/doxygen-1.8.14
-
-RUN mkdir -p /opt/plantuml
-RUN wget -O /opt/plantuml/plantuml.jar http://sourceforge.net/projects/plantuml/files/plantuml.jar/download
-ENV PLANTUML_JAR=/opt/plantuml/plantuml.jar
-
-CMD cd /opt/rippled/docs && doxygen source.dox

docs/Doxyfile

@@ -0,0 +1,343 @@
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+DOXYFILE_ENCODING      = UTF-8
+PROJECT_NAME           = "rippled"
+PROJECT_NUMBER         =
+PROJECT_BRIEF          =
+PROJECT_LOGO           =
+PROJECT_LOGO           =
+OUTPUT_DIRECTORY       = $(DOXYGEN_OUTPUT_DIRECTORY)
+CREATE_SUBDIRS         = NO
+ALLOW_UNICODE_NAMES    = NO
+OUTPUT_LANGUAGE        = English
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       =
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = YES
+FULL_PATH_NAMES        = NO
+STRIP_FROM_PATH        = src/
+STRIP_FROM_INC_PATH    =
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = YES
+QT_AUTOBRIEF           = NO
+MULTILINE_CPP_IS_BRIEF = NO
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 4
+ALIASES                =
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+OPTIMIZE_FOR_FORTRAN   = NO
+OPTIMIZE_OUTPUT_VHDL   = NO
+EXTENSION_MAPPING      =
+MARKDOWN_SUPPORT       = YES
+AUTOLINK_SUPPORT       = YES
+BUILTIN_STL_SUPPORT    = YES
+CPP_CLI_SUPPORT        = NO
+SIP_SUPPORT            = NO
+IDL_PROPERTY_SUPPORT   = YES
+DISTRIBUTE_GROUP_DOC   = NO
+GROUP_NESTED_COMPOUNDS = NO
+SUBGROUPING            = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS  = NO
+TYPEDEF_HIDES_STRUCT   = NO
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = YES
+EXTRACT_PACKAGE        = NO
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = YES
+EXTRACT_ANON_NSPACES   = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+HIDE_COMPOUND_REFERENCE= NO
+SHOW_INCLUDE_FILES     = NO
+SHOW_GROUPED_MEMB_INC  = NO
+FORCE_LOCAL_INCLUDES   = NO
+INLINE_INFO            = NO
+SORT_MEMBER_DOCS       = NO
+SORT_BRIEF_DOCS        = NO
+SORT_MEMBERS_CTORS_1ST = YES
+SORT_GROUP_NAMES       = NO
+SORT_BY_SCOPE_NAME     = NO
+STRICT_PROTO_MATCHING  = NO
+GENERATE_TODOLIST      = NO
+GENERATE_TESTLIST      = NO
+GENERATE_BUGLIST       = NO
+GENERATE_DEPRECATEDLIST= NO
+ENABLED_SECTIONS       =
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = NO
+SHOW_FILES             = NO
+SHOW_NAMESPACES        = YES
+FILE_VERSION_FILTER    =
+LAYOUT_FILE            =
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = NO
+WARN_AS_ERROR          = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = \
+    . \
+
+
+INPUT_ENCODING         = UTF-8
+FILE_PATTERNS          = *.h *.cpp *.md
+RECURSIVE              = YES
+EXCLUDE                = \
+    .github \
+    external/ed25519-donna \
+    external/secp256k1 \
+
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       =
+EXCLUDE_SYMBOLS        =
+EXAMPLE_PATH           =
+EXAMPLE_PATTERNS       =
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             =  \
+     docs/images/            \
+     docs/images/consensus/  \
+     src/test/csf/     \
+
+INPUT_FILTER           =
+FILTER_PATTERNS        =
+FILTER_SOURCE_FILES    = NO
+FILTER_SOURCE_PATTERNS =
+USE_MDFILE_AS_MAINPAGE = ./README.md
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+REFERENCES_LINK_SOURCE = YES
+SOURCE_TOOLTIPS        = YES
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = YES
+CLANG_ASSISTED_PARSING = NO
+CLANG_OPTIONS          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            =
+HTML_FOOTER            =
+HTML_STYLESHEET        =
+HTML_EXTRA_STYLESHEET  =
+HTML_EXTRA_FILES       =
+HTML_COLORSTYLE_HUE    = 220
+HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_GAMMA  = 80
+HTML_TIMESTAMP         = NO
+HTML_DYNAMIC_SECTIONS  = NO
+HTML_INDEX_NUM_ENTRIES = 100
+GENERATE_DOCSET        = NO
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+DOCSET_PUBLISHER_NAME  = Publisher
+GENERATE_HTMLHELP      = NO
+CHM_FILE               =
+HHC_LOCATION           =
+GENERATE_CHI           = NO
+CHM_INDEX_ENCODING     =
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+GENERATE_QHP           = NO
+QCH_FILE               =
+QHP_NAMESPACE          = org.doxygen.Project
+QHP_VIRTUAL_FOLDER     = doc
+QHP_CUST_FILTER_NAME   =
+QHP_CUST_FILTER_ATTRS  =
+QHP_SECT_FILTER_ATTRS  =
+QHG_LOCATION           =
+GENERATE_ECLIPSEHELP   = NO
+ECLIPSE_DOC_ID         = org.doxygen.Project
+DISABLE_INDEX          = NO
+GENERATE_TREEVIEW      = NO
+ENUM_VALUES_PER_LINE   = 4
+TREEVIEW_WIDTH         = 250
+EXT_LINKS_IN_WINDOW    = NO
+FORMULA_FONTSIZE       = 10
+FORMULA_TRANSPARENT    = YES
+USE_MATHJAX            = NO
+MATHJAX_FORMAT         = HTML-CSS
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_EXTENSIONS     =
+MATHJAX_CODEFILE       =
+SEARCHENGINE           = YES
+SERVER_BASED_SEARCH    = NO
+EXTERNAL_SEARCH        = NO
+SEARCHENGINE_URL       =
+SEARCHDATA_FILE        = searchdata.xml
+EXTERNAL_SEARCH_ID     =
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         =
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4
+EXTRA_PACKAGES         =
+LATEX_HEADER           =
+LATEX_FOOTER           =
+LATEX_EXTRA_STYLESHEET =
+LATEX_EXTRA_FILES      =
+PDF_HYPERLINKS         = YES
+USE_PDFLATEX           = YES
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+LATEX_SOURCE_CODE      = NO
+LATEX_BIB_STYLE        = plain
+LATEX_TIMESTAMP        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    =
+RTF_EXTENSIONS_FILE    =
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_SUBDIR             =
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+GENERATE_DOCBOOK       = NO
+DOCBOOK_OUTPUT         = docbook
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = YES
+EXPAND_ONLY_PREDEF     = YES
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = $(DOXYGEN_INCLUDE_PATH)
+INCLUDE_FILE_PATTERNS  =
+PREDEFINED             = DOXYGEN \
+                         GENERATING_DOCS \
+                         _MSC_VER \
+                         NUDB_POSIX_FILE=1
+
+EXPAND_AS_DEFINED      =
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+TAGFILES               = $(DOXYGEN_TAGFILES)
+GENERATE_TAGFILE       =
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+EXTERNAL_PAGES         = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = NO
+DIA_PATH               =
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = YES
+# DOT_NUM_THREADS = 0 means 1 for every processor.
+DOT_NUM_THREADS        = 0
+DOT_FONTNAME           = Helvetica
+DOT_FONTSIZE           = 10
+DOT_FONTPATH           =
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = NO
+UML_LIMIT_NUM_FIELDS   = 10
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+CALLER_GRAPH           = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = png
+INTERACTIVE_SVG        = NO
+DOT_PATH               = $(DOXYGEN_DOT_PATH)
+DOTFILE_DIRS           =
+MSCFILE_DIRS           =
+DIAFILE_DIRS           =
+PLANTUML_JAR_PATH      = $(DOXYGEN_PLANTUML_JAR_PATH)
+PLANTUML_INCLUDE_PATH  =
+DOT_GRAPH_MAX_NODES    = 50
+MAX_DOT_GRAPH_DEPTH    = 0
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES

docs/README.md

@@ -1,76 +1,63 @@
 # Building documentation
 
-## Specifying Files
-
-To specify the source files for which to build documentation, modify `INPUT`
-and its related fields in `docs/source.dox`. Note that the `INPUT` paths are
-relative to the `docs/` directory.
-
-## Install Dependencies
-
-### Windows
+## Dependencies
 
 Install these dependencies:
 
-1. Install [Doxygen](http://www.stack.nl/~dimitri/doxygen/download.html)
+- [Doxygen](http://www.doxygen.nl): All major platforms have [official binary
+  distributions](http://www.doxygen.nl/download.html#srcbin), or you can
+  build from [source](http://www.doxygen.nl/download.html#srcbin).
 
-### MacOS
+  - MacOS: We recommend installing via Homebrew: `brew install doxygen`.
+    The executable will be installed in `/usr/local/bin` which is already
+    in the default `PATH`.
 
-1. Install doxygen:
-  * Use homebrew to install: `brew install doxygen`.  The executable will be
-    installed in `/usr/local/bin` which is already in your path.
-  * Alternatively, install from here: [doxygen](http://www.stack.nl/~dimitri/doxygen/download.html).
-    You'll then need to make doxygen available to your command line.  You can
-    do this by adding a symbolic link from `/usr/local/bin` to the doxygen
-    executable.  For example, `$ ln -s /Applications/Doxygen.app/Contents/Resources/doxygen /usr/local/bin/doxygen`
+    If you use the official binary distribution, then you'll need to make
+    Doxygen available to your command line. You can do this by adding
+    a symbolic link from `/usr/local/bin` to the `doxygen` executable. For
+    example,
 
-### Linux
+    ```
+    $ ln -s /Applications/Doxygen.app/Contents/Resources/doxygen /usr/local/bin/doxygen
+    ```
 
-1. Install doxygen using your package manager OR from source using the links above.
+- [PlantUML](http://plantuml.com): 
 
-### [Optional] Install Plantuml (all platforms)
+  1. Install a functioning Java runtime, if you don't already have one.
+  2. Download [`plantuml.jar`](http://sourceforge.net/projects/plantuml/files/plantuml.jar/download).
 
-Doxygen supports the optional use of [plantuml](http://plantuml.com) to 
-generate diagrams from `@startuml` sections. We don't currently rely on this
-functionality for docs, so it's largely optional. Requirements:
+- [Graphviz](https://www.graphviz.org):
 
-1. Download/install a functioning java runtime, if you don't already have one.
-2. Download [plantuml](http://plantuml.com) from
-   [here](http://sourceforge.net/projects/plantuml/files/plantuml.jar/download).
-   Set a system environment variable named `PLANTUML_JAR` with a value of the fullpath
-   to the file system location of the `plantuml.jar` file you downloaded.
+  - Linux: Install from your package manager.
+  - Windows: Use an [official installer](https://graphviz.gitlab.io/_pages/Download/Download_windows.html).
+  - MacOS: Install via Homebrew: `brew install graphviz`.
 
-## Do it
-
-### all platforms
-
-From the rippled root folder:
-```
-cd docs
-mkdir -p html_doc
-doxygen source.dox
-```
-The output will be in `docs/html_doc`.
 
 ## Docker
 
-(applicable to all platforms)
-    
-Instead of installing the doxygen tools locally, you can use the provided `Dockerfile` to create
-an ubuntu based image for running the tools:
+Instead of installing the above dependencies locally, you can use the official
+build environment Docker image, which has all of them installed already.
 
 1. Install [Docker](https://docs.docker.com/engine/installation/)
-2. Build Docker image. From the rippled root folder:
+2. Pull the image:
+  ```
+  sudo docker pull rippleci/rippled-ci-builder:2944b78d22db
+  ```
+3. Run the image from the project folder:
+  ```
+  sudo docker run -v $PWD:/opt/rippled --rm rippleci/rippled-ci-builder:2944b78d22db
+  ```
+
+
+## Build
+
+There is a `docs` target in the CMake configuration.
 
 ```
-sudo docker build -t rippled-docs docs/
+mkdir build
+cd build
+cmake ..
+cmake --build . --target docs
 ```
 
-Then to run the image, from the rippled root folder:
-
-```
-sudo docker run -v $PWD:/opt/rippled --rm rippled-docs
-```
-
-The output will be in `docs/html_doc`.
-
+The output will be in `build/docs/html`.

docs/build/conan.md

@@ -0,0 +1,124 @@
+## A crash course in CMake and Conan
+
+To better understand how to use Conan,
+we should first understand _why_ we use Conan,
+and to understand that,
+we need to understand how we use CMake.
+
+
+### CMake
+
+Technically, you don't need CMake to build this project.
+You could manually compile every translation unit into an object file,
+using the right compiler options,
+and then manually link all those objects together,
+using the right linker options.
+However, that is very tedious and error-prone,
+which is why we lean on tools like CMake.
+
+We have written CMake configuration files
+([`CMakeLists.txt`](./CMakeLists.txt) and friends)
+for this project so that CMake can be used to correctly compile and link
+all of the translation units in it.
+Or rather, CMake will generate files for a separate build system
+(e.g. Make, Ninja, Visual Studio, Xcode, etc.)
+that compile and link all of the translation units.
+Even then, CMake has parameters, some of which are platform-specific.
+In CMake's parlance, parameters are specially-named **variables** like
+[`CMAKE_BUILD_TYPE`][build_type] or
+[`CMAKE_MSVC_RUNTIME_LIBRARY`][runtime].
+Parameters include:
+
+- what build system to generate files for
+- where to find the compiler and linker
+- where to find dependencies, e.g. libraries and headers
+- how to link dependencies, e.g. any special compiler or linker flags that
+    need to be used with them, including preprocessor definitions
+- how to compile translation units, e.g. with optimizations, debug symbols,
+    position-independent code, etc.
+- on Windows, which runtime library to link with
+
+For some of these parameters, like the build system and compiler,
+CMake goes through a complicated search process to choose default values.
+For others, like the dependencies,
+_we_ had written in the CMake configuration files of this project
+our own complicated process to choose defaults.
+For most developers, things "just worked"... until they didn't, and then
+you were left trying to debug one of these complicated processes, instead of
+choosing and manually passing the parameter values yourself.
+
+You can pass every parameter to CMake on the command line,
+but writing out these parameters every time we want to configure CMake is
+a pain.
+Most humans prefer to put them into a configuration file, once, that
+CMake can read every time it is configured.
+For CMake, that file is a [toolchain file][toolchain].
+
+
+### Conan
+
+These next few paragraphs on Conan are going to read much like the ones above
+for CMake.
+
+Technically, you don't need Conan to build this project.
+You could manually download, configure, build, and install all of the
+dependencies yourself, and then pass all of the parameters necessary for
+CMake to link to those dependencies.
+To guarantee ABI compatibility, you must be sure to use the same set of
+compiler and linker options for all dependencies _and_ this project.
+However, that is very tedious and error-prone, which is why we lean on tools
+like Conan.
+
+We have written a Conan configuration file ([`conanfile.py`](../../conanfile.py))
+so that Conan can be used to correctly download, configure, build, and install
+all of the dependencies for this project,
+using a single set of compiler and linker options for all of them.
+It generates files that contain almost all of the parameters that CMake
+expects.
+Those files include:
+
+- A single toolchain file.
+- For every dependency, a CMake [package configuration file][pcf],
+    [package version file][pvf], and for every build type, a package
+    targets file.
+    Together, these files implement version checking and define `IMPORTED`
+    targets for the dependencies.
+
+The toolchain file itself amends the search path
+([`CMAKE_PREFIX_PATH`][prefix_path]) so that [`find_package()`][find_package]
+will [discover][search] the generated package configuration files.
+
+**Nearly all we must do to properly configure CMake is pass the toolchain
+file.**
+What CMake parameters are left out?
+You'll still need to pick a build system generator,
+and if you choose a single-configuration generator,
+you'll need to pass the `CMAKE_BUILD_TYPE`,
+which should match the `build_type` setting you gave to Conan.
+
+Even then, Conan has parameters, some of which are platform-specific.
+In Conan's parlance, parameters are either settings or options.
+**Settings** are shared by all packages, e.g. the build type.
+**Options** are specific to a given package, e.g. whether to build and link
+OpenSSL as a shared library.
+
+For settings, Conan goes through a complicated search process to choose
+defaults.
+For options, each package recipe defines its own defaults.
+
+You can pass every parameter to Conan on the command line,
+but it is more convenient to put them in a configuration file, once, that
+Conan can read every time it is configured.
+For Conan, that file is a [profile][].
+**All we must do to properly configure Conan is edit and pass the profile.**
+By default, Conan will use the profile named "default".
+
+[build_type]: https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
+[find_package]: https://cmake.org/cmake/help/latest/command/find_package.html
+[pcf]: https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#package-configuration-file
+[prefix_path]: https://cmake.org/cmake/help/latest/variable/CMAKE_PREFIX_PATH.html
+[profile]: https://docs.conan.io/en/latest/reference/profiles.html
+[pvf]: https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#package-version-file
+[runtime]: https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
+[search]: https://cmake.org/cmake/help/latest/command/find_package.html#search-procedure
+[toolchain]: https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html

docs/build/depend.md

@@ -0,0 +1,98 @@
+We recommend two different methods to depend on libxrpl in your own [CMake][]
+project.
+Both methods add a CMake library target named `xrpl::libxrpl`.
+
+
+## Conan requirement 
+
+The first method adds libxrpl as a [Conan][] requirement.
+With this method, there is no need for a Git [submodule][].
+It is good for when you just need a dependency on libxrpl as-is.
+
+```
+# This conanfile.txt is just an example.
+[requires]
+xrpl/1.10.0
+
+[generators]
+CMakeDeps
+CMakeToolchain
+```
+
+```
+# If you want to depend on a version of libxrpl that is not in ConanCenter,
+# then you can export the recipe from the rippled project.
+conan export <path>
+```
+
+```cmake
+# Find and link the library in your CMake project.
+find_package(xrpl)
+target_link_libraries(<target> PUBLIC xrpl::libxrpl)
+```
+
+```
+# Download, build, and connect dependencies with Conan.
+mkdir .build
+cd .build
+mkdir -p build/generators
+conan install \
+  --install-folder build/generators \
+  --build missing \
+  --settings build_type=Release \
+  ..
+cmake \
+  -DCMAKE_TOOLCHAIN_FILE=build/generators/conan_toolchain.cmake \
+  -DCMAKE_BUILD_TYPE=Release \
+  ..
+cmake --build . --parallel
+```
+
+
+## CMake subdirectory
+
+The second method adds the [rippled][] project as a CMake
+[subdirectory][add_subdirectory].
+This method works well when you keep the rippled project as a Git
+[submodule][].
+It's good for when you want to make changes to libxrpl as part of your own
+project.
+Be careful, though.
+Your project will inherit all of the same CMake options,
+so watch out for name collisions.
+We still recommend using [Conan][] to download, build, and connect dependencies.
+
+```
+# Add the project as a Git submodule.
+mkdir submodules
+git submodule add https://github.com/XRPLF/rippled.git submodules/rippled
+```
+
+```cmake
+# Add and link the library in your CMake project.
+add_subdirectory(submodules/rippled)
+target_link_libraries(<target> PUBLIC xrpl::libxrpl)
+```
+
+```
+# Download, build, and connect dependencies with Conan.
+mkdir .build
+cd .build
+conan install \
+  --output-folder . \
+  --build missing \
+  --settings build_type=Release \
+  ../submodules/rippled
+cmake \
+  -DCMAKE_TOOLCHAIN_FILE=build/generators/conan_toolchain.cmake \
+  -DCMAKE_BUILD_TYPE=Release \
+  ..
+cmake --build . --parallel
+```
+
+
+[add_subdirectory]: https://cmake.org/cmake/help/latest/command/add_subdirectory.html
+[submodule]: https://git-scm.com/book/en/v2/Git-Tools-Submodules
+[rippled]: https://github.com/ripple/rippled
+[Conan]: https://docs.conan.io/
+[CMake]: https://cmake.org/cmake/help/latest/

docs/build/environment.md

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

docs/build/install.md

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

docs/consensus.md

@@ -4,7 +4,7 @@
 
 Consensus is the task of reaching agreement within a distributed system in the
 presence of faulty or even malicious participants.  This document outlines the
-[Ripple Consensus Algorithm](https://ripple.com/files/ripple/consensus/whitepaper.pdf)
+[XRP Ledger Consensus Algorithm](https://arxiv.org/abs/1802.07242)
 as implemented in [rippled](https://github.com/ripple/rippled), but
 focuses on its utility as a generic consensus algorithm independent of the
 detailed mechanics of the Ripple Consensus Ledger. Most notably, the algorithm
@@ -469,7 +469,7 @@ struct Ledger
   // Whether the ledger's close time was a non-trivial consensus result
   bool closeAgree() const;
 
-  // The close time resolution used in determing the close time
+  // The close time resolution used in determining the close time
   NetClock::duration closeTimeResolution() const;
 
   // The (effective) close time, based on the closeTimeResolution
@@ -558,7 +558,7 @@ struct ConsensusResult
     ConsensusTimer roundTime;
 
     // Indicates state in which consensus ended.  Once in the accept phase
-    // will be either Yes or MovedOn
+    // will be either Yes or MovedOn or Expired
     ConsensusState state = ConsensusState::No;
 };