Set version to 2.0.1

Update to #4849, using a workaround for spurious codecov upload errors.

Spurious codecov upload errors are expected in public repos which rely
on PRs via forks. Retrying uploads is a decent and easy workaround.

.clang-format

@@ -0,0 +1,87 @@
+---
+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 ]
+IncludeCategories:
+  - Regex:           '^<(BeastConfig)'
+    Priority:        0
+  - Regex:           '^<(ripple)/'
+    Priority:        2
+  - Regex:           '^<(boost)/'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        4
+IncludeIsMainRegex: '$'
+IndentCaseLabels: true
+IndentFunctionDeclarationAfterType: false
+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
+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

@@ -0,0 +1,6 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 60%
+        threshold: 2%

.git-blame-ignore-revs

@@ -0,0 +1,4 @@
+# This feature requires Git >= 2.24
+# To use it by default in git blame:
+# git config blame.ignoreRevsFile .git-blame-ignore-revs
+50760c693510894ca368e90369b0cc2dabfd07f3

.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,32 @@
+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 }} \
+          ${{ 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,26 @@
+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 export external/snappy snappy/1.1.10@
+        conan export external/soci soci/4.0.3@
+    - name: install dependencies
+      shell: bash
+      run: |
+        mkdir ${build_dir}
+        cd ${build_dir}
+        conan install \
+          --output-folder . \
+          --build missing \
+          --settings build_type=${{ inputs.configuration }} \
+          ..

.github/pull_request_template.md

@@ -0,0 +1,79 @@
+<!--
+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.
+-->
+
+## 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,61 @@
+name: clang-format
+
+on: [push, pull_request]
+
+jobs:
+  check:
+    runs-on: ubuntu-20.04
+    env:
+      CLANG_VERSION: 10
+    steps:
+    - uses: actions/checkout@v3
+    - 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 src/ripple
+      run: find src/ripple -type f \( -name '*.cpp' -o -name '*.h' -o -name '*.ipp' \) -print0 | xargs -0 clang-format-${CLANG_VERSION} -i
+    - name: Format src/test
+      run: find src/test -type f \( -name '*.cpp' -o -name '*.h' -o -name '*.ipp' \) -print0 | xargs -0 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@v2
+      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 c,cpp,h,cxx,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
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  job:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    container:
+      image: docker://rippleci/rippled-ci-builder:2944b78d22db
+    steps:
+      - name: checkout
+        uses: actions/checkout@v3
+      - 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@v3
+    - 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@v2
+      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/macos.yml

@@ -0,0 +1,51 @@
+name: macos
+on: [push, pull_request]
+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@v3
+      - name: install Ninja
+        if: matrix.generator == 'Ninja'
+        run: brew install ninja
+      - name: check environment
+        run: |
+          echo ${PATH} | tr ':' '\n'
+          python --version
+          conan --version
+          cmake --version
+          env | sort
+      - name: configure Conan
+        run : |
+          conan profile get env.CXXFLAGS default || true
+          conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: ${{ matrix.generator }}
+          configuration: ${{ matrix.configuration }}
+      - name: test
+        run: |
+          ${build_dir}/rippled --unittest

.github/workflows/nix.yml

@@ -0,0 +1,234 @@
+name: nix
+on: [push, pull_request]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+# This workflow has two job matrixes.
+# They can be considered phases because the second matrix ("test")
+# depends 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 second phase has a job in the matrix for each test configuration.
+# It installs dependency binaries from the cache, whichever was used,
+# and builds and tests rippled.
+
+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: checkout
+        uses: actions/checkout@v3
+      - name: check environment
+        run: |
+          echo ${PATH} | tr ':' '\n'
+          conan --version
+          cmake --version
+          env | sort
+      - name: configure Conan
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+        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
+          # 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
+        run: |
+          echo outcome=$(conan user --remote ripple ${{ secrets.CONAN_USERNAME }} --password ${{ secrets.CONAN_TOKEN }} >&2 && echo success || echo failure) | tee ${GITHUB_OUTPUT}
+      - name: archive profile
+        # Create this archive before dependencies are added to the local cache.
+        run: tar -czf conan.tar -C ~/.conan .
+      - name: list missing binaries
+        id: binaries
+        # 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=${{ matrix.configuration }} --json 2>/dev/null  | grep '^\[') | tee ${GITHUB_OUTPUT}
+      - name: build dependencies
+        if: (steps.binaries.outputs.missing != '[]')
+        uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: upload dependencies to remote
+        if: (steps.binaries.outputs.missing != '[]') && (steps.remote.outputs.outcome == 'success')
+        run: conan upload --remote ripple '*' --all --parallel --confirm
+      - name: recreate archive with dependencies
+        if: (steps.binaries.outputs.missing != '[]') && (steps.remote.outputs.outcome == 'failure')
+        run: tar -czf conan.tar -C ~/.conan .
+      - name: upload archive
+        uses: actions/upload-artifact@v3
+        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: download cache
+        uses: actions/download-artifact@v3
+        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: |
+          echo ${PATH} | tr ':' '\n'
+          conan --version
+          cmake --version
+          env | sort
+          ls ~/.conan
+      - name: checkout
+        uses: actions/checkout@v3
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          cmake-args: ${{ 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: download cache
+        uses: actions/download-artifact@v3
+        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: |
+          echo ${PATH} | tr ':' '\n'
+          conan --version
+          cmake --version
+          gcovr --version
+          env | sort
+          ls ~/.conan
+      - name: checkout
+        uses: actions/checkout@v3
+      - name: dependencies
+        uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          cmake-args: >-
+            -Dcoverage=ON
+            -Dcoverage_format=xml
+            -DCODE_COVERAGE_VERBOSE=ON
+            -DCMAKE_CXX_FLAGS="-O0"
+            -DCMAKE_C_FLAGS="-O0"
+          cmake-target: coverage
+      - name: build
+        shell: bash
+        run: |
+          mv "${build_dir}/coverage.xml" ./
+      - name: archive coverage report
+        uses: actions/upload-artifact@v3
+        with:
+          name: coverage.xml
+          path: coverage.xml
+          retention-days: 30
+      - name: upload coverage report
+        uses: wandalen/wretry.action@v1.3.0
+        with:
+          action: codecov/codecov-action@v3
+          with: |
+            files: coverage.xml
+            fail_ci_if_error: true
+            verbose: true
+            token: ${{ secrets.CODECOV_TOKEN }}
+          attempt_limit: 5
+          attempt_delay: 35000 # in milliseconds

.github/workflows/windows.yml

@@ -0,0 +1,101 @@
+name: windows
+
+on: [push, pull_request]
+
+# 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:
+        generator:
+          - Visual Studio 16 2019
+        configuration:
+          - Release
+          # Github hosted runners tend to hang when running Debug unit tests.
+          # Instead of trying to work around it, disable the Debug job until
+          # something beefier (i.e. a heavy self-hosted runner) becomes
+          # available.
+          # - Debug
+    runs-on: windows-2019
+    env:
+      build_dir: .build
+    steps:
+      - name: checkout
+        uses: actions/checkout@v3
+      - name: choose Python
+        uses: actions/setup-python@v3
+        with:
+          python-version: 3.9
+      - name: learn Python cache directory
+        id: pip-cache
+        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@v3
+        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: |
+          $env:PATH -split ';'
+          python --version
+          conan --version
+          cmake --version
+          dir env:
+      - name: configure Conan
+        shell: bash
+        env:
+          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+        run: |
+          conan profile new default --detect
+          conan profile update settings.compiler.runtime=MT${{ matrix.configuration == 'Debug' && 'd' || '' }} default
+          # 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
+        shell: bash
+        id: remote
+        run: |
+          echo outcome=$(conan user --remote ripple ${{ secrets.CONAN_USERNAME }} \
+            --password ${{ secrets.CONAN_TOKEN }} >&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=${{ matrix.configuration }} --json 2>/dev/null  | grep '^\[') | tee ${GITHUB_OUTPUT}
+      - name: build dependencies
+        uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: upload dependencies to remote
+        if: (steps.binaries.outputs.missing != '[]') && (steps.remote.outputs.outcome == 'success')
+        run: conan upload --remote ripple '*' --all --parallel --confirm
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: '${{ matrix.generator }}'
+          configuration: ${{ matrix.configuration }}
+          # Hard code for now. Move to the matrix if varied options are needed
+          cmake-args: '-Dassert=ON -Dreporting=OFF -Dunity=ON'
+          cmake-target: install
+      - name: test (permitted to silently fail)
+        shell: bash
+        # Github runners are resource limited, which causes unit tests to fail
+        # (e.g. OOM). To allow forward progress until self-hosted runners are
+        # up and running reliably, allow the job to succeed even if tests fail.
+        continue-on-error: true
+        run: |
+          ${build_dir}/${{ matrix.configuration }}/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,8 +36,11 @@ Release/*.*
 *.gcda
 *.gcov
 
-# Ignore locally installed node_modules
-/node_modules
+# Levelization checking
+Builds/levelization/results/rawincludes.txt
+Builds/levelization/results/paths.txt
+Builds/levelization/results/includes/
+Builds/levelization/results/includedby/
 
 # Ignore tmp directory.
 tmp
@@ -50,15 +56,15 @@ debug_log.txt
 # Ignore customized configs
 rippled.cfg
 validators.txt
-test/config.js
 
 # Doxygen generated documentation output
 HtmlDocumentation
+docs/html_doc
 
 # Xcode user-specific project settings
 # Xcode
 .DS_Store
-*/build/*
+/build/
 *.pbxuser
 !default.pbxuser
 *.mode1v3
@@ -94,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,12 +0,0 @@
-[submodule "docs/docca"]
-	path = docs/docca
-	url = https://github.com/vinniefalco/docca.git
-[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: v10.0.1
+  hooks:
+  - id: clang-format

.travis.yml

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

BUILD.md

@@ -0,0 +1,428 @@
+| :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.55](https://conan.io/downloads.html)
+- [CMake 3.16](https://cmake.org/download/)
+
+`rippled` is written in the C++20 dialect and includes the `<concepts>` header.
+The [minimum compiler versions][2] required are:
+
+| Compiler    | Version |
+|-------------|---------|
+| GCC         | 11      |
+| Clang       | 13      |
+| Apple Clang | 13.1.6  |
+| MSVC        | 19.23   |
+
+### Linux
+
+The Ubuntu operating system has received the highest level of
+quality assurance, testing, and support.
+
+Here are [sample instructions for setting up a C++ development environment on Linux](./docs/build/environment.md#linux).
+
+### Mac
+
+Many rippled engineers use macOS for development.
+
+Here are [sample instructions for setting up a C++ development environment on macOS](./docs/build/environment.md#macos).
+
+### Windows
+
+Windows is not recommended for production use at this time.
+
+- Additionally, 32-bit Windows development is not supported.
+- Visual Studio 2022 is not yet supported.
+  - rippled generally requires [Boost][] 1.77, which Conan cannot build with VS 2022.
+  - Until rippled is updated for compatibility with later versions of Boost, Windows developers may need to use Visual Studio 2019.
+
+[Boost]: https://www.boost.org/
+
+## Steps
+
+### 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
+   ```
+
+**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
+   ```
+
+**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 export external/snappy snappy/1.1.10@
+   ```
+
+Export our [Conan recipe for SOCI](./external/soci).
+It patches their CMake to correctly import its dependencies.
+
+   ```
+   conan export external/soci soci/4.0.3@
+   ```
+
+### 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. Generate CMake files for every configuration you want to build. 
+
+    ```
+    conan install .. --output-folder . --build missing --settings build_type=Release
+    conan install .. --output-folder . --build missing --settings build_type=Debug
+    ```
+
+    For a single-configuration generator, e.g. `Unix Makefiles` or `Ninja`,
+    you only need to run this command once.
+    For a multi-configuration generator, e.g. `Visual Studio`, you may want to
+    run it more than once.
+
+    Each of these commands should 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:
+
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release ..
+    ```
+
+    Pass the CMake variable [`CMAKE_BUILD_TYPE`][build_type]
+    and make sure it matches the `build_type` setting you chose in the previous
+    step.
+
+    Multi-config generators:
+
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
+    ```
+
+    **Note:** You can pass build options for `rippled` in this step.
+
+4. Build `rippled`.
+
+   For a single-configuration generator, it will build whatever configuration
+   you passed for `CMAKE_BUILD_TYPE`. For a multi-configuration generator,
+   you must pass the option `--config` to select the build configuration. 
+
+   Single-config generators:
+
+   ```
+   cmake --build .
+   ```
+
+   Multi-config generators:
+
+   ```
+   cmake --build . --config Release
+   cmake --build . --config Debug
+   ```
+
+5. Test rippled.
+
+   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 -Dcoverage_test_parallelism=2 -Dcoverage_format=html-details -Dcoverage_extra_args="--json coverage.json" -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
+cmake --build . --target coverage
+```
+
+After the `coverage` target is completed, the generated coverage report will be
+stored inside the build directory, as either of:
+
+- file named `coverage.`_extension_ , with a suitable extension for the report format, or
+- directory named `coverage`, with the `index.html` and other files inside, for the `html-details` or `html-nested` report formats.
+
+
+## Options
+
+| Option | Default Value | Description |
+| --- | ---| ---|
+| `assert` | OFF | Enable assertions.
+| `reporting` | OFF | Build the reporting mode feature. |
+| `coverage` | OFF | Prepare the coverage report. |
+| `tests` | ON | Build tests. |
+| `unity` | ON | Configure a unity build. |
+| `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
+
+[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).
+
+
+### 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/ArchLinux/PKGBUILD

@@ -1,38 +0,0 @@
-# Maintainer: Roberto Catini <roberto.catini@gmail.com>
-
-pkgname=rippled
-pkgrel=1
-pkgver=0
-pkgdesc="Ripple peer-to-peer network daemon"
-arch=('i686' 'x86_64')
-url="https://github.com/ripple/rippled"
-license=('custom:ISC')
-depends=('protobuf' 'openssl' 'boost-libs')
-makedepends=('git' 'scons' 'boost')
-backup=("etc/$pkgname/rippled.cfg")
-source=("git://github.com/ripple/rippled.git#branch=master")
-sha512sums=('SKIP')
-
-pkgver() {
-	cd "$srcdir/$pkgname"
-	git describe --long --tags | sed -r 's/([^-]*-g)/r\1/;s/-/./g'
-}
-
-build() {
-	cd "$srcdir/$pkgname"
-	scons
-}
-
-check() {
-	cd "$srcdir/$pkgname"
-	build/rippled --unittest
-}
-
-package() {
-	cd "$srcdir/$pkgname"
-	install -D -m644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
-	install -D build/rippled "$pkgdir/usr/bin/rippled"
-	install -D -m644 doc/rippled-example.cfg "$pkgdir/etc/$pkgname/rippled.cfg"
-	mkdir -p "$pkgdir/var/lib/$pkgname/db"
-	mkdir -p "$pkgdir/var/log/$pkgname"
-}

Builds/CMake/CMakeFuncs.cmake

@@ -1,706 +1,207 @@
-# 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 AND NOT CMAKE_BUILD_TYPE)
-    if (APPLE)
-      set(target clang.debug)
-    elseif(WIN32)
-      set(target msvc)
+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()
-      set(target gcc.debug)
+      string(REPLACE "/" "\\" groupname ${curdir})
+      source_group(${groupname} FILES
+        ${source_dir}/${curdir}/${child})
     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()
-    # Promote these values to the CACHE, then unset the locals
-    # to prevent shadowing.
-    set(CMAKE_C_COMPILER ${CMAKE_C_COMPILER} CACHE FILEPATH
-      "Path to a program" FORCE)
-    unset(CMAKE_C_COMPILER)
-    set(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER} CACHE FILEPATH
-      "Path to a program" FORCE)
-    unset(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)
-  endif()
-
-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")
-
-  if (static AND (WIN32 OR APPLE))
-    message(FATAL_ERROR "Static linking is 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 curdir)
-  file(GLOB children RELATIVE ${PROJECT_SOURCE_DIR}/${curdir}
-    ${PROJECT_SOURCE_DIR}/${curdir}/*)
-  foreach (child ${children})
-    if (IS_DIRECTORY ${PROJECT_SOURCE_DIR}/${curdir}/${child})
-      group_sources(${curdir}/${child})
-    else()
-      string(REPLACE "/" "\\" groupname ${curdir})
-      source_group(${groupname} FILES
-        ${PROJECT_SOURCE_DIR}/${curdir}/${child})
+  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 ()
+
+function (print_ep_logs _target)
+  ExternalProject_Get_Property (${_target} STAMP_DIR)
+  add_custom_command(TARGET ${_target} POST_BUILD
+    COMMENT "${_target} BUILD OUTPUT"
+    COMMAND ${CMAKE_COMMAND}
+      -DIN_FILE=${STAMP_DIR}/${_target}-build-out.log
+      -P ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/echo_file.cmake
+    COMMAND ${CMAKE_COMMAND}
+      -DIN_FILE=${STAMP_DIR}/${_target}-build-err.log
+      -P ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/echo_file.cmake)
+endfunction ()
+
+#[=========================================================[
+  This is a function override for one function in the
+  standard ExternalProject module. We want to change
+  the generated build script slightly to include printing
+  the build logs in the case of failure. Those modifications
+  have been made here. This function override could break
+  in the future if the ExternalProject module changes internal
+  function names or changes the way it generates the build
+  scripts.
+   See:
+    https://gitlab.kitware.com/cmake/cmake/blob/df1ddeec128d68cc636f2dde6c2acd87af5658b6/Modules/ExternalProject.cmake#L1855-1952
+#]=========================================================]
+
+function(_ep_write_log_script name step cmd_var)
+  ExternalProject_Get_Property(${name} stamp_dir)
+  set(command "${${cmd_var}}")
+
+  set(make "")
+  set(code_cygpath_make "")
+  if(command MATCHES "^\\$\\(MAKE\\)")
+    # GNU make recognizes the string "$(MAKE)" as recursive make, so
+    # ensure that it appears directly in the makefile.
+    string(REGEX REPLACE "^\\$\\(MAKE\\)" "\${make}" command "${command}")
+    set(make "-Dmake=$(MAKE)")
+
+    if(WIN32 AND NOT CYGWIN)
+      set(code_cygpath_make "
+if(\${make} MATCHES \"^/\")
+  execute_process(
+    COMMAND cygpath -w \${make}
+    OUTPUT_VARIABLE cygpath_make
+    ERROR_VARIABLE cygpath_make
+    RESULT_VARIABLE cygpath_error
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(NOT cygpath_error)
+    set(make \${cygpath_make})
+  endif()
+endif()
+")
     endif()
+  endif()
+
+  set(config "")
+  if("${CMAKE_CFG_INTDIR}" MATCHES "^\\$")
+    string(REPLACE "${CMAKE_CFG_INTDIR}" "\${config}" command "${command}")
+    set(config "-Dconfig=${CMAKE_CFG_INTDIR}")
+  endif()
+
+  # Wrap multiple 'COMMAND' lines up into a second-level wrapper
+  # script so all output can be sent to one log file.
+  if(command MATCHES "(^|;)COMMAND;")
+    set(code_execute_process "
+${code_cygpath_make}
+execute_process(COMMAND \${command} RESULT_VARIABLE result)
+if(result)
+  set(msg \"Command failed (\${result}):\\n\")
+  foreach(arg IN LISTS command)
+    set(msg \"\${msg} '\${arg}'\")
   endforeach()
-endmacro()
+  message(FATAL_ERROR \"\${msg}\")
+endif()
+")
+    set(code "")
+    set(cmd "")
+    set(sep "")
+    foreach(arg IN LISTS command)
+      if("x${arg}" STREQUAL "xCOMMAND")
+        if(NOT "x${cmd}" STREQUAL "x")
+          string(APPEND code "set(command \"${cmd}\")${code_execute_process}")
+        endif()
+        set(cmd "")
+        set(sep "")
+      else()
+        string(APPEND cmd "${sep}${arg}")
+        set(sep ";")
+      endif()
+    endforeach()
+    string(APPEND code "set(command \"${cmd}\")${code_execute_process}")
+    file(GENERATE OUTPUT "${stamp_dir}/${name}-${step}-$<CONFIG>-impl.cmake" CONTENT "${code}")
+    set(command ${CMAKE_COMMAND} "-Dmake=\${make}" "-Dconfig=\${config}" -P ${stamp_dir}/${name}-${step}-$<CONFIG>-impl.cmake)
+  endif()
 
-macro(add_with_props src_var files)
-  list(APPEND ${src_var} ${files})
-  foreach (arg ${ARGN})
-    set(props "${props} ${arg}")
+  # Wrap the command in a script to log output to files.
+  set(script ${stamp_dir}/${name}-${step}-$<CONFIG>.cmake)
+  set(logbase ${stamp_dir}/${name}-${step})
+  set(code "
+${code_cygpath_make}
+function (_echo_file _fil)
+  file (READ \${_fil} _cont)
+  execute_process (COMMAND \${CMAKE_COMMAND} -E echo \"\${_cont}\")
+endfunction ()
+set(command \"${command}\")
+execute_process(
+  COMMAND \${command}
+  RESULT_VARIABLE result
+  OUTPUT_FILE \"${logbase}-out.log\"
+  ERROR_FILE \"${logbase}-err.log\"
+  )
+if(result)
+  set(msg \"Command failed: \${result}\\n\")
+  foreach(arg IN LISTS command)
+    set(msg \"\${msg} '\${arg}'\")
   endforeach()
-  set_source_files_properties(
-    ${files}
-    PROPERTIES COMPILE_FLAGS
-    ${props})
-endmacro()
+  execute_process (COMMAND \${CMAKE_COMMAND} -E echo \"Build output for ${logbase} : \")
+  _echo_file (\"${logbase}-out.log\")
+  _echo_file (\"${logbase}-err.log\")
+  set(msg \"\${msg}\\nSee above\\n\")
+  message(FATAL_ERROR \"\${msg}\")
+else()
+  set(msg \"${name} ${step} command succeeded.  See also ${logbase}-*.log\")
+  message(STATUS \"\${msg}\")
+endif()
+")
+  file(GENERATE OUTPUT "${script}" CONTENT "${code}")
+  set(command ${CMAKE_COMMAND} ${make} ${config} -P ${script})
+  set(${cmd_var} "${command}" PARENT_SCOPE)
+endfunction()
 
-############################################################
+find_package(Git)
 
-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()
-    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()
-
-    set(Boost_USE_STATIC_LIBS on)
-    set(Boost_USE_MULTITHREADED on)
-    set(Boost_USE_STATIC_RUNTIME off)
-    find_package(Boost COMPONENTS
-      ${ARGN})
-
-    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()
-      include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
-      link_directories(${Boost_LIBRARY_DIRS})
-    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 (DEFINED ENV{OPENSSL_ROOT})
-      include_directories($ENV{OPENSSL_ROOT}/include)
-      link_directories($ENV{OPENSSL_ROOT}/lib)
-    endif()
-  else()
-    if (static)
-      set(tmp CMAKE_FIND_LIBRARY_SUFFIXES)
-      set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
-    endif()
-
-    find_package(OpenSSL)
-
-    if (static)
-      set(CMAKE_FIND_LIBRARY_SUFFIXES tmp)
-    endif()
-
-    if (OPENSSL_FOUND)
-      include_directories(${OPENSSL_INCLUDE_DIR})
-    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()
-  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)
-      set(SANITIZER_LIBRARIES asan)
-      add_definitions(-DSANITIZER=ASAN)
-    endif()
-    if (${ci_san} STREQUAL thread)
-      set(SANITIZER_LIBRARIES tsan)
-      add_definitions(-DSANITIZER=TSAN)
-    endif()
-  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)
-    if ("${LD_VERSION}" MATCHES "GNU gold")
-      append_flags(CMAKE_EXE_LINKER_FLAGS -fuse-ld=gold)
+# function that calls git log to get current hash
+function (git_hash hash_val)
+  # note: optional second extra string argument not in signature
+  if (NOT GIT_FOUND)
+    return ()
+  endif ()
+  set (_hash "")
+  set (_format "%H")
+  if (ARGC GREATER_EQUAL 2)
+    string (TOLOWER ${ARGV1} _short)
+    if (_short STREQUAL "short")
+      set (_format "%h")
     endif ()
-    unset(LD_VERSION)
-  endif()
+  endif ()
+  execute_process (COMMAND ${GIT_EXECUTABLE} "log" "--pretty=${_format}" "-n1"
+                   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                   RESULT_VARIABLE _git_exit_code
+                   OUTPUT_VARIABLE _temp_hash
+                   OUTPUT_STRIP_TRAILING_WHITESPACE
+                   ERROR_QUIET)
+  if (_git_exit_code EQUAL 0)
+    set (_hash ${_temp_hash})
+  endif ()
+  set (${hash_val} "${_hash}" PARENT_SCOPE)
+endfunction ()
 
-  # 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>)
+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 ()
 
-  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 (NOT WIN32)
-    add_definitions(-D_FILE_OFFSET_BITS=64)
-    append_flags(CMAKE_CXX_FLAGS -frtti -std=c++14 -Wno-invalid-offsetof
-      -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_definitions(-DBEAST_COMPILE_OBJECTIVE_CPP=1)
-      add_compile_options(
-        -Wno-deprecated -Wno-deprecated-declarations -Wno-unused-variable -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 extension: 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
-      /wd"4018"
-      /wd"4244"
-      /wd"4267"
-      /wd"4800"            # Disable C4800(int to bool performance)
-      /wd"4503"            # 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()
-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}
-        crypto ssl ${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)
-  endif (NOT MSVC)
-endmacro()

Builds/CMake/CMake_sqlite3.txt

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

Builds/CMake/CodeCoverage.cmake

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

Builds/CMake/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")

Builds/CMake/RippledCompiler.cmake

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

Builds/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" "${CMAKE_BINARY_DIR}/proto_gen" "${CMAKE_BINARY_DIR}/proto_gen_grpc"
+  DEPENDENCIES rippled
+)

Builds/CMake/RippledDocs.cmake

@@ -0,0 +1,84 @@
+#[===================================================================[
+   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
+  src/ripple/*.h
+  src/ripple/*.cpp
+  src/ripple/*.md
+  src/test/*.h
+  src/test/*.md
+  Builds/*/README.md)
+list(APPEND doxygen_input
+  README.md
+  RELEASENOTES.md
+  src/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}")

Builds/CMake/RippledInstall.cmake

@@ -0,0 +1,50 @@
+#[===================================================================[
+   install stuff
+#]===================================================================]
+
+install (
+  TARGETS
+    common
+    opts
+    ripple_syslibs
+    ripple_boost
+    xrpl_core
+  EXPORT RippleExports
+  LIBRARY DESTINATION lib
+  ARCHIVE DESTINATION lib
+  RUNTIME DESTINATION bin
+  INCLUDES DESTINATION include)
+
+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)
+  install (TARGETS rippled RUNTIME DESTINATION bin)
+  set_target_properties(rippled PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
+  install (
+    FILES
+      ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/RippleConfig.cmake
+      ${CMAKE_CURRENT_BINARY_DIR}/RippleConfigVersion.cmake
+    DESTINATION lib/cmake/ripple)
+  # 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)
+  ")
+endif ()

Builds/CMake/RippledInterface.cmake

@@ -0,0 +1,96 @@
+#[===================================================================[
+   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
+    $<$<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>)
+target_compile_options (opts
+  INTERFACE
+    $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
+    $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<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)

Builds/CMake/RippledMultiConfig.cmake

@@ -0,0 +1,39 @@
+#[===================================================================[
+   multiconfig misc
+#]===================================================================]
+
+if (is_multiconfig)
+  # This code finds all source files in the src subdirectory for inclusion
+  # in the IDE file tree as non-compiled sources. Since this file list will
+  # have some overlap with files we have already added to our targets to
+  # be compiled, we explicitly remove any of these target source files from
+  # this list.
+  file (GLOB_RECURSE all_sources RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+    CONFIGURE_DEPENDS
+    src/*.* Builds/*.md docs/*.md src/*.md Builds/*.cmake)
+  file(GLOB md_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} CONFIGURE_DEPENDS
+    *.md)
+  LIST(APPEND all_sources ${md_files})
+  foreach (_target secp256k1::secp256k1 ed25519::ed25519 xrpl_core rippled)
+    get_target_property (_type ${_target} TYPE)
+    if(_type STREQUAL "INTERFACE_LIBRARY")
+      continue()
+    endif()
+    get_target_property (_src ${_target} SOURCES)
+    list (REMOVE_ITEM all_sources ${_src})
+  endforeach ()
+  target_sources (rippled PRIVATE ${all_sources})
+  set_property (
+    SOURCE ${all_sources}
+    APPEND
+    PROPERTY HEADER_FILE_ONLY true)
+  if (MSVC)
+    set_property(
+      DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      PROPERTY VS_STARTUP_PROJECT rippled)
+  endif ()
+
+  group_sources(src)
+  group_sources(docs)
+  group_sources(Builds)
+endif ()

Builds/CMake/RippledRelease.cmake

@@ -0,0 +1,180 @@
+#[===================================================================[
+   package/container targets - (optional)
+#]===================================================================]
+
+if (is_root_project)
+  if (NOT DOCKER)
+    find_program (DOCKER docker)
+  endif ()
+
+  if (DOCKER)
+    # if no container label is provided, use current git hash
+    git_hash (commit_hash)
+    if (NOT container_label)
+      set (container_label ${commit_hash})
+    endif ()
+    message (STATUS "using [${container_label}] as build container tag...")
+
+    file (MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/packages)
+
+    #[===================================================================[
+        rpm
+    #]===================================================================]
+    add_custom_target (rpm_container
+      docker build
+        --pull
+        --build-arg GIT_COMMIT=${commit_hash}
+        -t rippleci/rippled-rpm-builder:${container_label}
+        $<$<BOOL:${rpm_cache_from}>:--cache-from=${rpm_cache_from}>
+        -f centos-builder/Dockerfile .
+      WORKING_DIRECTORY  ${CMAKE_CURRENT_SOURCE_DIR}/Builds/containers
+      VERBATIM
+      USES_TERMINAL
+      COMMAND_EXPAND_LISTS
+      SOURCES
+        Builds/containers/centos-builder/Dockerfile
+        Builds/containers/centos-builder/centos_setup.sh
+        Builds/containers/shared/update-rippled.sh
+        Builds/containers/shared/update_sources.sh
+        Builds/containers/shared/rippled.service
+        Builds/containers/shared/rippled-reporting.service
+        Builds/containers/packaging/rpm/rippled.spec
+        Builds/containers/packaging/rpm/build_rpm.sh
+        Builds/containers/packaging/rpm/50-rippled.preset
+        Builds/containers/packaging/rpm/50-rippled-reporting.preset
+        bin/getRippledInfo
+    )
+    exclude_from_default (rpm_container)
+    add_custom_target (rpm
+      docker run
+        -v ${CMAKE_CURRENT_SOURCE_DIR}:/opt/rippled_bld/pkg/rippled
+        -v ${CMAKE_CURRENT_BINARY_DIR}/packages:/opt/rippled_bld/pkg/out
+        -t rippled-rpm-builder:${container_label}
+        /bin/bash -c "cp -fpu rippled/Builds/containers/packaging/rpm/build_rpm.sh . && ./build_rpm.sh"
+      VERBATIM
+      USES_TERMINAL
+      COMMAND_EXPAND_LISTS
+      SOURCES
+        Builds/containers/packaging/rpm/rippled.spec
+    )
+    exclude_from_default (rpm)
+    if (NOT have_package_container)
+      add_dependencies(rpm rpm_container)
+    endif ()
+    #[===================================================================[
+        dpkg
+    #]===================================================================]
+    # currently use ubuntu 18.04 as a base b/c it has one of
+    # the lower versions of libc among ubuntu and debian releases.
+    # we could change this in the future and build with some other deb
+    # based system.
+    add_custom_target (dpkg_container
+      docker build
+        --pull
+        --build-arg DIST_TAG=18.04
+        --build-arg GIT_COMMIT=${commit_hash}
+        -t rippled-dpkg-builder:${container_label}
+        $<$<BOOL:${dpkg_cache_from}>:--cache-from=${dpkg_cache_from}>
+        -f ubuntu-builder/Dockerfile .
+      WORKING_DIRECTORY  ${CMAKE_CURRENT_SOURCE_DIR}/Builds/containers
+      VERBATIM
+      USES_TERMINAL
+      COMMAND_EXPAND_LISTS
+      SOURCES
+        Builds/containers/packaging/dpkg/debian/rippled-reporting.links
+        Builds/containers/packaging/dpkg/debian/copyright
+        Builds/containers/packaging/dpkg/debian/rules
+        Builds/containers/packaging/dpkg/debian/rippled-reporting.install
+        Builds/containers/packaging/dpkg/debian/rippled-reporting.postinst
+        Builds/containers/packaging/dpkg/debian/rippled.links
+        Builds/containers/packaging/dpkg/debian/rippled.prerm
+        Builds/containers/packaging/dpkg/debian/rippled.postinst
+        Builds/containers/packaging/dpkg/debian/rippled-dev.install
+        Builds/containers/packaging/dpkg/debian/dirs
+        Builds/containers/packaging/dpkg/debian/rippled.postrm
+        Builds/containers/packaging/dpkg/debian/rippled.conffiles
+        Builds/containers/packaging/dpkg/debian/compat
+        Builds/containers/packaging/dpkg/debian/source/format
+        Builds/containers/packaging/dpkg/debian/source/local-options
+        Builds/containers/packaging/dpkg/debian/README.Debian
+        Builds/containers/packaging/dpkg/debian/rippled.install
+        Builds/containers/packaging/dpkg/debian/rippled.preinst
+        Builds/containers/packaging/dpkg/debian/docs
+        Builds/containers/packaging/dpkg/debian/control
+        Builds/containers/packaging/dpkg/debian/rippled-reporting.dirs
+        Builds/containers/packaging/dpkg/build_dpkg.sh
+        Builds/containers/ubuntu-builder/Dockerfile
+        Builds/containers/ubuntu-builder/ubuntu_setup.sh
+        bin/getRippledInfo
+        Builds/containers/shared/install_cmake.sh
+        Builds/containers/shared/update-rippled.sh
+        Builds/containers/shared/update_sources.sh
+        Builds/containers/shared/rippled.service
+        Builds/containers/shared/rippled-reporting.service
+        Builds/containers/shared/rippled-logrotate
+        Builds/containers/shared/update-rippled-cron
+    )
+    exclude_from_default (dpkg_container)
+    add_custom_target (dpkg
+      docker run
+        -v ${CMAKE_CURRENT_SOURCE_DIR}:/opt/rippled_bld/pkg/rippled
+        -v ${CMAKE_CURRENT_BINARY_DIR}/packages:/opt/rippled_bld/pkg/out
+        -t rippled-dpkg-builder:${container_label}
+        /bin/bash -c "cp -fpu rippled/Builds/containers/packaging/dpkg/build_dpkg.sh . && ./build_dpkg.sh"
+      VERBATIM
+      USES_TERMINAL
+      COMMAND_EXPAND_LISTS
+      SOURCES
+        Builds/containers/packaging/dpkg/debian/control
+    )
+    exclude_from_default (dpkg)
+    if (NOT have_package_container)
+      add_dependencies(dpkg dpkg_container)
+    endif ()
+    #[===================================================================[
+        ci container
+    #]===================================================================]
+    # now use the same ubuntu image for our travis-ci docker images,
+    # but we use a newer distro (18.04 vs 16.04).
+    #
+    # the following steps assume the github pkg repo, but it's possible to
+    # adapt these for other docker hub repositories.
+    #
+    # steps for publishing a new CI image when you make changes:
+    #
+    #   mkdir bld.ci && cd bld.ci && cmake -Dpackages_only=ON -Dcontainer_label=CI_LATEST
+    #   cmake --build . --target ci_container --verbose
+    #   docker tag rippled-ci-builder:CI_LATEST <HUB REPO PATH>/rippled-ci-builder:YYYY-MM-DD
+    #      (NOTE: change YYYY-MM-DD to match current date, or use a different
+    #             tag/version scheme if you prefer)
+    #   docker push <HUB REPO PATH>/rippled-ci-builder:YYYY-MM-DD
+    #      (NOTE: <HUB REPO PATH> is probably your user or org name if using
+    #             docker hub, or it might be something like
+    #             docker.pkg.github.com/ripple/rippled if using the github pkg
+    #             registry. for any registry, you will need to be logged-in via
+    #             docker and have push access.)
+    #
+    # ...then change the DOCKER_IMAGE line in .travis.yml :
+    #     - DOCKER_IMAGE="<HUB REPO PATH>/rippled-ci-builder:YYYY-MM-DD"
+    add_custom_target (ci_container
+      docker build
+        --pull
+        --build-arg DIST_TAG=18.04
+        --build-arg GIT_COMMIT=${commit_hash}
+        --build-arg CI_USE=true
+        -t rippled-ci-builder:${container_label}
+        $<$<BOOL:${ci_cache_from}>:--cache-from=${ci_cache_from}>
+        -f ubuntu-builder/Dockerfile .
+      WORKING_DIRECTORY  ${CMAKE_CURRENT_SOURCE_DIR}/Builds/containers
+      VERBATIM
+      USES_TERMINAL
+      COMMAND_EXPAND_LISTS
+      SOURCES
+        Builds/containers/ubuntu-builder/Dockerfile
+        Builds/containers/ubuntu-builder/ubuntu_setup.sh
+    )
+    exclude_from_default (ci_container)
+  else ()
+    message (STATUS "docker NOT found -- won't be able to build containers for packaging")
+  endif ()
+endif ()

Builds/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 ()

Builds/CMake/RippledSettings.cmake

@@ -0,0 +1,130 @@
+#[===================================================================[
+   declare user options/settings
+#]===================================================================]
+
+include(ProcessorCount)
+
+ProcessorCount(PROCESSOR_COUNT)
+
+option(assert "Enables asserts, even in release builds" OFF)
+
+option(reporting "Build rippled with reporting mode enabled" OFF)
+
+option(tests "Build tests" ON)
+
+option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
+if(unity)
+  if(NOT is_ci)
+    set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
+  endif()
+endif()
+if(is_gcc OR is_clang)
+  option(coverage "Generates coverage info." OFF)
+  option(profile "Add profiling flags" OFF)
+  set(coverage_test_parallelism "${PROCESSOR_COUNT}" CACHE STRING
+    "Unit tests parallelism for the purpose of coverage report.")
+  set(coverage_format "html-details" CACHE STRING
+    "Output format of the coverage report.")
+  set(coverage_extra_args "" CACHE STRING
+    "Additional arguments to pass to gcovr.")
+  set(coverage_test "" CACHE STRING
+    "On gcc & clang, the specific unit test(s) to run for coverage. Default is all tests.")
+  if(coverage_test AND NOT coverage)
+    set(coverage ON CACHE BOOL "gcc/clang only" FORCE)
+  endif()
+  option(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()

Builds/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 develop branch unless we are on master/release
+  if (NOT (current_branch STREQUAL "master" OR current_branch STREQUAL "release"))
+    set (current_branch "develop")
+  endif ()
+  message (STATUS "tracking ValidatorKeys branch: ${current_branch}")
+
+  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 ()

Builds/CMake/RippledVersion.cmake

@@ -0,0 +1,15 @@
+#[===================================================================[
+   read version from source
+#]===================================================================]
+
+file (STRINGS src/ripple/protocol/impl/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 ()

Builds/CMake/SociConfig.cmake.patched

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

Builds/CMake/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()

Builds/CMake/deps/Protobuf.cmake

@@ -0,0 +1,27 @@
+find_package(Protobuf 3.8)
+
+set(output_dir ${CMAKE_BINARY_DIR}/proto_gen)
+file(MAKE_DIRECTORY ${output_dir})
+set(ccbd ${CMAKE_CURRENT_BINARY_DIR})
+set(CMAKE_CURRENT_BINARY_DIR ${output_dir})
+protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS src/ripple/proto/ripple.proto)
+set(CMAKE_CURRENT_BINARY_DIR ${ccbd})
+
+target_include_directories(xrpl_core SYSTEM PUBLIC
+    # The generated implementation imports the header relative to the output
+    # directory.
+    $<BUILD_INTERFACE:${output_dir}>
+    $<BUILD_INTERFACE:${output_dir}/src>
+)
+target_sources(xrpl_core PRIVATE ${output_dir}/src/ripple/proto/ripple.pb.cc)
+install(
+  FILES ${output_dir}/src/ripple/proto/ripple.pb.h
+  DESTINATION include/ripple/proto)
+target_link_libraries(xrpl_core PUBLIC protobuf::libprotobuf)
+target_compile_options(xrpl_core
+  PUBLIC
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >
+)

Builds/CMake/deps/gRPC.cmake

@@ -0,0 +1,82 @@
+find_package(gRPC 1.23)
+
+#[=================================[
+   generate protobuf sources for
+   grpc defs and bundle into a
+   static lib
+#]=================================]
+set(output_dir "${CMAKE_BINARY_DIR}/proto_gen_grpc")
+set(GRPC_GEN_DIR "${output_dir}/ripple/proto")
+file(MAKE_DIRECTORY ${GRPC_GEN_DIR})
+set(GRPC_PROTO_SRCS)
+set(GRPC_PROTO_HDRS)
+set(GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
+file(GLOB_RECURSE GRPC_DEFINITION_FILES "${GRPC_PROTO_ROOT}/*.proto")
+foreach(file ${GRPC_DEFINITION_FILES})
+  # /home/user/rippled/src/ripple/proto/org/.../v1/get_ledger.proto
+  get_filename_component(_abs_file ${file} ABSOLUTE)
+  # /home/user/rippled/src/ripple/proto/org/.../v1
+  get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
+  # get_ledger
+  get_filename_component(_basename ${file} NAME_WE)
+  # /home/user/rippled/src/ripple/proto
+  get_filename_component(_proto_inc ${GRPC_PROTO_ROOT} DIRECTORY) # updir one level
+  # org/.../v1/get_ledger.proto
+  file(RELATIVE_PATH _rel_root_file ${_proto_inc} ${_abs_file})
+  # org/.../v1
+  get_filename_component(_rel_root_dir ${_rel_root_file} DIRECTORY)
+  # src/ripple/proto/org/.../v1
+  file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir})
+
+  # .cmake/proto_gen_grpc/ripple/proto/org/.../v1/get_ledger.grpc.pb.cc
+  set(src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
+  set(src_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.cc")
+  set(hdr_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.h")
+  set(hdr_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.h")
+  add_custom_command(
+    OUTPUT ${src_1} ${src_2} ${hdr_1} ${hdr_2}
+    COMMAND protobuf::protoc
+    ARGS --grpc_out=${GRPC_GEN_DIR}
+         --cpp_out=${GRPC_GEN_DIR}
+         --plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
+         -I ${_proto_inc} -I ${_rel_dir}
+         ${_abs_file}
+    DEPENDS ${_abs_file} protobuf::protoc gRPC::grpc_cpp_plugin
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Running gRPC C++ protocol buffer compiler on ${file}"
+    VERBATIM)
+    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES
+      GENERATED TRUE
+      SKIP_UNITY_BUILD_INCLUSION ON
+    )
+    list(APPEND GRPC_PROTO_SRCS ${src_1} ${src_2})
+    list(APPEND GRPC_PROTO_HDRS ${hdr_1} ${hdr_2})
+endforeach()
+
+target_include_directories(xrpl_core SYSTEM PUBLIC
+  $<BUILD_INTERFACE:${output_dir}>
+  $<BUILD_INTERFACE:${output_dir}/ripple/proto>
+  # The generated sources include headers relative to this path. Fix it later.
+  $<INSTALL_INTERFACE:include/ripple/proto>
+)
+target_sources(xrpl_core PRIVATE ${GRPC_PROTO_SRCS})
+install(
+  DIRECTORY ${output_dir}/ripple
+  DESTINATION include/
+  FILES_MATCHING PATTERN "*.h"
+)
+target_link_libraries(xrpl_core PUBLIC
+  "gRPC::grpc++"
+  # libgrpc is missing references.
+  absl::random_random
+)
+target_compile_options(xrpl_core
+  PRIVATE
+    $<$<BOOL:${MSVC}>:-wd4065>
+    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
+  PUBLIC
+    $<$<BOOL:${MSVC}>:-wd4996>
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >)

Builds/CMake/echo_file.cmake

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

Builds/Docker/Dockerfile

@@ -1,30 +0,0 @@
-# rippled
-
-# use the ubuntu base image
-FROM ubuntu
-MAINTAINER Roberto Catini roberto.catini@gmail.com
-
-# make sure the package repository is up to date
-RUN apt-get update
-RUN apt-get -y upgrade
-
-# install the dependencies
-RUN apt-get -y install git scons pkg-config protobuf-compiler libprotobuf-dev libssl-dev libboost1.55-all-dev
-
-# download source code from official repository
-RUN git clone https://github.com/ripple/rippled.git src; cd src/; git checkout master
-
-# compile
-RUN cd src/; scons build/rippled
-
-# move to root directory and strip
-RUN cp src/build/rippled rippled; strip rippled
-
-# copy default config
-RUN cp src/doc/rippled-example.cfg rippled.cfg
-
-# clean source
-RUN rm -r src
-
-# launch rippled when launching the container
-ENTRYPOINT ./rippled

Builds/Docker/Dockerfile-testnet

@@ -1,23 +0,0 @@
-FROM ubuntu
-MAINTAINER Torrie Fischer <torrie@ripple.com>
-
-RUN apt-get update -qq &&\
-    apt-get install -qq software-properties-common &&\
-    apt-add-repository -y ppa:ubuntu-toolchain-r/test &&\
-    apt-add-repository -y ppa:afrank/boost &&\
-    apt-get update -qq
-
-RUN apt-get purge -qq libboost1.48-dev &&\
-    apt-get install -qq libprotobuf8 libboost1.57-all-dev
-
-RUN mkdir -p /srv/rippled/data
-
-VOLUME /srv/rippled/data/
-
-ENTRYPOINT ["/srv/rippled/bin/rippled"]
-CMD ["--conf", "/srv/rippled/data/rippled.cfg"]
-EXPOSE 51235/udp
-EXPOSE 5005/tcp
-
-ADD ./rippled.cfg /srv/rippled/data/rippled.cfg
-ADD ./rippled /srv/rippled/bin/

Builds/Docker/build-ci.sh

@@ -1,13 +0,0 @@
-set -e
-
-mkdir -p build/docker/
-cp doc/rippled-example.cfg build/clang.debug/rippled build/docker/
-cp Builds/Docker/Dockerfile-testnet build/docker/Dockerfile
-mv build/docker/rippled-example.cfg build/docker/rippled.cfg
-strip build/docker/rippled
-docker build -t ripple/rippled:$CIRCLE_SHA1 build/docker/
-docker tag ripple/rippled:$CIRCLE_SHA1 ripple/rippled:latest
-
-if [ -z "$CIRCLE_PR_NUMBER" ]; then
-  docker tag ripple/rippled:$CIRCLE_SHA1 ripple/rippled:$CIRCLE_BRANCH
-fi

Builds/Docker/push-to-hub.sh

@@ -1,16 +0,0 @@
-set -e
-
-if [ -z "$DOCKER_EMAIL" -o -z "$DOCKER_USERNAME" -o -z "$DOCKER_PASSWORD" ];then
-  echo "Docker credentials are not set. Can't login to docker, no containers will be pushed."
-  exit 0
-fi
-
-if [ -n "$CIRCLE_PR_NUMBER" ]; then
-  echo "Not pushing results of a pull request build."
-  exit 0
-fi
-
-docker login -e $DOCKER_EMAIL -u $DOCKER_USERNAME -p $DOCKER_PASSWORD
-docker push ripple/rippled:$CIRCLE_SHA1
-docker push ripple/rippled:$CIRCLE_BRANCH
-docker push ripple/rippled:latest

Builds/Eclipse/README.md

@@ -1,31 +0,0 @@
-**Requirements**
-
-1. Java Runtime Environment (JRE)
-2. Eclipse with CDT (tested on Luna):
-http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/lunasr2
-3. Eclipse SCons plugin: http://sconsolidator.com/  
-**WARNING**: by default the SCons plugin uses 16 threads. Go to
-*Window->Preferences->SCons->Build Settings* in Eclipse and make it
-use only 4-8 jobs(threads) or whatever you feel confortable with. It will
-positively freeze your system if you run with 16 threads/jobs.  
-
-![scons](scons.png) 
-
-**Getting Started**
-
-After setting up Eclipse just do a File->New->Other...
-Select: C/C++ / New SCons project from existing source
-Point the importer to the folder where the SConstruct resides (the root
-folder of your git workspace normally)  
-
-**Build**
-
-Just hit Project->Build All in Eclipse to get started. And remember to not
-let it run 16 threads! 
-
-**Debug**
-
-Start a new Eclipse debug configuration and set binary to run to build/rippled
-(assuming you have built it).  
-
-![debug](debug.png) 

Builds/Fedora/install_rippled_depends_fedora.sh

@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-
-#
-# This scripts installs the dependencies needed by rippled. It should be run
-# with sudo.
-#
-
-if [ ! -f /etc/fedora-release ]; then
-    echo "This script is meant to be run on fedora"
-    exit 1
-fi
-
-fedora_release=$(grep -o '[0-9]*' /etc/fedora-release)
-
-if (( $(bc <<< "${fedora_release} < 22") )); then
-    echo "This script is meant to run on fedora 22 or greater"
-    exit 1
-fi
-
-yum -y update
-yum -y group install "Development Tools"
-yum -y install gcc-c++ scons openssl-devel openssl-static protobuf-devel protobuf-static boost-devel boost-static libstdc++-static

Builds/QtCreator/.gitignore

@@ -1,5 +0,0 @@
-# QTCreator
-
-Makefile
-*.user
-

Builds/QtCreator/rippled.pro

@@ -1,112 +0,0 @@
-
-# Ripple protocol buffers
-
-PROTOS = ../../src/ripple_data/protocol/ripple.proto
-PROTOS_DIR = ../../build/proto
-
-# Google Protocol Buffers support
-
-protobuf_h.name = protobuf header
-protobuf_h.input = PROTOS
-protobuf_h.output = $${PROTOS_DIR}/${QMAKE_FILE_BASE}.pb.h
-protobuf_h.depends = ${QMAKE_FILE_NAME}
-protobuf_h.commands = protoc --cpp_out=$${PROTOS_DIR} --proto_path=${QMAKE_FILE_PATH} ${QMAKE_FILE_NAME}
-protobuf_h.variable_out = HEADERS
-QMAKE_EXTRA_COMPILERS += protobuf_h
-
-protobuf_cc.name = protobuf implementation
-protobuf_cc.input = PROTOS
-protobuf_cc.output = $${PROTOS_DIR}/${QMAKE_FILE_BASE}.pb.cc
-protobuf_cc.depends = $${PROTOS_DIR}/${QMAKE_FILE_BASE}.pb.h
-protobuf_cc.commands = $$escape_expand(\\n)
-#protobuf_cc.variable_out = SOURCES
-QMAKE_EXTRA_COMPILERS += protobuf_cc
-
-# Ripple compilation
-
-DESTDIR = ../../build/QtCreator
-OBJECTS_DIR = ../../build/QtCreator/obj
-
-TEMPLATE = app
-CONFIG += console thread warn_off
-CONFIG -= qt gui
-
-DEFINES += _DEBUG
-
-linux-g++:QMAKE_CXXFLAGS += \
-    -Wall \
-    -Wno-sign-compare \
-    -Wno-char-subscripts \
-    -Wno-invalid-offsetof \
-    -Wno-unused-parameter \
-    -Wformat \
-    -O0 \
-    -std=c++11 \
-    -pthread
-
-INCLUDEPATH += \
-    "../../src/leveldb/" \
-    "../../src/leveldb/port" \
-    "../../src/leveldb/include" \
-    $${PROTOS_DIR}
-
-OTHER_FILES += \
-#   $$files(../../src/*, true) \
-#   $$files(../../src/beast/*) \
-#   $$files(../../src/beast/modules/beast_basics/diagnostic/*)
-#   $$files(../../src/beast/modules/beast_core/, true)
-
-UI_HEADERS_DIR += ../../src/ripple_basics
-
-# ---------
-# New style
-#
-SOURCES += \
-    ../../src/ripple/beast/ripple_beast.unity.cpp \
-    ../../src/ripple/beast/ripple_beastc.c \
-    ../../src/ripple/common/ripple_common.unity.cpp \
-    ../../src/ripple/http/ripple_http.unity.cpp \
-    ../../src/ripple/json/ripple_json.unity.cpp \
-    ../../src/ripple/peerfinder/ripple_peerfinder.unity.cpp \
-    ../../src/ripple/radmap/ripple_radmap.unity.cpp \
-    ../../src/ripple/resource/ripple_resource.unity.cpp \
-    ../../src/ripple/sitefiles/ripple_sitefiles.unity.cpp \
-    ../../src/ripple/sslutil/ripple_sslutil.unity.cpp \
-    ../../src/ripple/testoverlay/ripple_testoverlay.unity.cpp \
-    ../../src/ripple/types/ripple_types.unity.cpp \
-    ../../src/ripple/validators/ripple_validators.unity.cpp
-
-# ---------
-# Old style
-#
-SOURCES += \
-    ../../src/ripple_app/ripple_app.unity.cpp \
-    ../../src/ripple_app/ripple_app_pt1.unity.cpp \
-    ../../src/ripple_app/ripple_app_pt2.unity.cpp \
-    ../../src/ripple_app/ripple_app_pt3.unity.cpp \
-    ../../src/ripple_app/ripple_app_pt4.unity.cpp \
-    ../../src/ripple_app/ripple_app_pt5.unity.cpp \
-    ../../src/ripple_app/ripple_app_pt6.unity.cpp \
-    ../../src/ripple_app/ripple_app_pt7.unity.cpp \
-    ../../src/ripple_app/ripple_app_pt8.unity.cpp \
-    ../../src/ripple_basics/ripple_basics.unity.cpp \
-    ../../src/ripple_core/ripple_core.unity.cpp \
-    ../../src/ripple_data/ripple_data.unity.cpp \
-    ../../src/ripple_hyperleveldb/ripple_hyperleveldb.unity.cpp \
-    ../../src/ripple_leveldb/ripple_leveldb.unity.cpp \
-    ../../src/ripple_net/ripple_net.unity.cpp \
-    ../../src/ripple_overlay/ripple_overlay.unity.cpp \
-    ../../src/ripple_rpc/ripple_rpc.unity.cpp \
-    ../../src/ripple_websocket/ripple_websocket.unity.cpp
-
-LIBS += \
-    -lboost_date_time-mt\
-    -lboost_filesystem-mt \
-    -lboost_program_options-mt \
-    -lboost_regex-mt \
-    -lboost_system-mt \
-    -lboost_thread-mt \
-    -lboost_random-mt \
-    -lprotobuf \
-    -lssl \
-    -lrt

Builds/README.md

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

Builds/Test.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 #    This file is part of rippled: https://github.com/ripple/rippled
-#    Copyright (c) 2012 - 2015 Ripple Labs Inc.
+#    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
@@ -22,10 +22,10 @@ Invocation:
 
 The build must succeed without shell aliases for this to work.
 
-To pass flags to scons, put them at the very end of the command line, after
+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 scons.
+    ./Builds/Test.py -- -j4  # Pass -j4 to cmake --build
 
 
 Common problems:
@@ -34,11 +34,7 @@ Common problems:
 
 2) OpenSSL not found. Solution: export OPENSSL_ROOT=[path to OpenSSL folder]
 
-3) scons is an alias. Solution: Create a script named "scons" somewhere in
-   your $PATH (eg. ~/bin/scons will often work).
-
-      #!/bin/sh
-      python /C/Python27/Scripts/scons.py "${@}"
+3) cmake is not found. Solution: Be sure cmake directory is on your $PATH
 
 """
 from __future__ import absolute_import, division, print_function, unicode_literals
@@ -61,26 +57,36 @@ def powerset(iterable):
 IS_WINDOWS = platform.system().lower() == 'windows'
 IS_OS_X = platform.system().lower() == 'darwin'
 
-if IS_WINDOWS or IS_OS_X:
-    ALL_TARGETS = [('debug',), ('release',)]
+# CMake
+if IS_WINDOWS:
+    CMAKE_UNITY_CONFIGS = ['Debug', 'Release']
+    CMAKE_NONUNITY_CONFIGS = ['Debug', 'Release']
 else:
-    ALL_TARGETS = [(cc + "." + target,)
+    CMAKE_UNITY_CONFIGS = []
+    CMAKE_NONUNITY_CONFIGS = []
+CMAKE_UNITY_COMBOS = { '' : [['rippled'], CMAKE_UNITY_CONFIGS],
+    '.nounity' : [['rippled'], 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 target in ['debug', 'release', 'coverage', 'profile',
-                                  'debug.nounity', 'release.nounity', 'coverage.nounity', 'profile.nounity']]
+                   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:
-    ALL_OPTIONS = [tuple(x) for x in powerset(['--assert'])]
+    CMAKE_ALL_GENERATE_OPTIONS = [tuple(x) for x in powerset(['-GNinja', '-Dassert=true'])]
 else:
-    ALL_OPTIONS = list(set(
-        [tuple(x) for x in powerset(['--ninja', '--static', '--assert', '--sanitize=address'])] +
-        [tuple(x) for x in powerset(['--ninja', '--static', '--assert', '--sanitize=thread'])]))
-
-# list of tuples of all possible options + all possible targets
-ALL_BUILDS = [options + target
-              for target in ALL_TARGETS
-              for options in ALL_OPTIONS]
+    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'
@@ -117,6 +123,19 @@ parser.add_argument(
     help='Add a prefix for unit tests',
 )
 
+parser.add_argument(
+    '--testjobs',
+    default='0',
+    type=int,
+    help='Run tests in parallel'
+)
+
+parser.add_argument(
+    '--ipv6',
+    action='store_true',
+    help='Use IPv6 localhost when running unit tests.',
+)
+
 parser.add_argument(
     '--clean', '-c',
     action='store_true',
@@ -130,15 +149,62 @@ parser.add_argument(
 )
 
 parser.add_argument(
-    'scons_args',
+    '--dir', '-d',
     default=(),
-    nargs='*'
+    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):
+def shell(cmd, args=(), silent=False, cust_env=None):
     """"Execute a shell command and return the output."""
     silent = ARGS.silent or silent
     verbose = not silent and ARGS.verbose
@@ -147,125 +213,189 @@ def shell(cmd, args=(), silent=False):
 
     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,
+        env=cust_env,
         shell=IS_WINDOWS)
     lines = []
     count = 0
-    for line in process.stdout:
-        # Python 2 vs. Python 3
-        if isinstance(line, str):
-            decoded = line
+    # 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:
-            decoded = line.decode()
-        lines.append(decoded)
-        if verbose:
-            print(decoded, end='')
-        elif not silent:
-            count += 1
-            if count >= 80:
-                print()
-                count = 0
-            else:
-                print('.', end='')
+            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_tests(args):
-    failed = []
-    if IS_WINDOWS:
-        binary_re = re.compile(r'build\\([^\\]+)\\rippled.exe')
-    else:
-        binary_re = re.compile(r'build/([^/]+)/rippled')
-    _, lines = shell('scons', ('-n', '--tree=derived',) + args, silent=True)
-    for line in lines:
-        match = binary_re.search(line)
-        if match:
-            executable, target = match.group(0, 1)
+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', )
+    # hack to extract cmake options/args from the legacy target format
+    if re.search('\.unity', cmake_dir):
+        args += ( '-Dunity=ON', )
+    if re.search('\.nounity', cmake_dir):
+        args += ( '-Dunity=OFF', )
+    if re.search('coverage', cmake_dir):
+        args += ( '-Dcoverage=ON', )
+    if re.search('profile', cmake_dir):
+        args += ( '-Dprofile=ON', )
+    if re.search('debug', cmake_dir):
+        args += ( '-DCMAKE_BUILD_TYPE=Debug', )
+    if re.search('release', cmake_dir):
+        args += ( '-DCMAKE_BUILD_TYPE=Release', )
+    m = re.search('gcc(-[^.]*)', cmake_dir)
+    if m:
+        args += ( '-DCMAKE_C_COMPILER=' + m.group(0),
+          '-DCMAKE_CXX_COMPILER=g++' + m.group(1), )
+    elif re.search('gcc', cmake_dir):
+        args += ( '-DCMAKE_C_COMPILER=gcc', '-DCMAKE_CXX_COMPILER=g++', )
+    m = re.search('clang(-[^.]*)', cmake_dir)
+    if m:
+        args += ( '-DCMAKE_C_COMPILER=' + m.group(0),
+          '-DCMAKE_CXX_COMPILER=clang++' + m.group(1), )
+    elif re.search('clang', cmake_dir):
+        args += ( '-DCMAKE_C_COMPILER=clang', '-DCMAKE_CXX_COMPILER=clang++', )
 
-            print('Unit tests for', target)
-            testflag = '--unittest'
-            quiet = ''
-            if ARGS.test:
-                testflag += ('=' + ARGS.test)
-            if ARGS.quiet:
-                quiet = '-q'
-            resultcode, lines = shell(executable, (testflag, quiet,))
+    args += ( os.path.join('..', '..', '..'), )
+    resultcode, lines = shell('cmake', args)
 
-            if resultcode:
-                if not ARGS.verbose:
-                    print('ERROR:', *lines, sep='')
-                failed.append([target, 'unittest'])
-                if not ARGS.keep_going:
-                    break
+    if resultcode:
+        print('Generating FAILED:')
+        if not ARGS.verbose:
+            print(*lines, sep='')
+        sys.exit(1)
 
-    return failed
+    os.chdir(old_dir)
 
-
-def run_build(args=None):
-    print('Building:', *args or ('(default)',))
-    resultcode, lines = shell('scons', args)
+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)
-    if '--ninja' in args:
-        resultcode, lines = shell('ninja')
 
-        if resultcode:
-            print('Ninja 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 = ''
+    ipv6 = ''
+    if ARGS.test:
+        testflag += ('=' + ARGS.test)
+    if ARGS.quiet:
+        quiet = '-q'
+    if ARGS.ipv6:
+        ipv6 = '--unittest-ipv6'
+    if ARGS.testjobs:
+        testjobs = ('--unittest-jobs=' + str(ARGS.testjobs))
+    resultcode, lines = shell(executable, (testflag, quiet, testjobs, ipv6))
 
+    if resultcode:
+        if not ARGS.verbose:
+            print('ERROR:', *lines, sep='')
+        failed.append([target, 'unittest'])
+
+    return failed
 
 def main():
-    if ARGS.all:
-        to_build = ALL_BUILDS
-    else:
-        to_build = [tuple(ARGS.scons_args)]
-
     all_failed = []
-
-    for build in to_build:
-        args = ()
-        # additional arguments come first
-        for arg in list(ARGS.scons_args):
-            if arg not in build:
-                args += (arg,)
-        args += build
-
-        run_build(args)
-        failed = run_tests(args)
-
-        if failed:
-            print('FAILED:', *(':'.join(f) for f in failed))
-            if not ARGS.keep_going:
-                sys.exit(1)
-            else:
-                all_failed.extend([','.join(build), ':'.join(f)]
-                    for f in 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:
-            print('Success')
+            generator_options = [tuple()]
 
-        if ARGS.clean:
-            shutil.rmtree('build')
-            if '--ninja' in args:
-                os.remove('build.ninja')
-                os.remove('.ninja_deps')
-                os.remove('.ninja_log')
+    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(to_build) > 1:
+        if len(all_failed) > 1:
             print()
             print('FAILED:', *(':'.join(f) for f in all_failed))
         sys.exit(1)

Builds/Ubuntu/build_clang_libs.sh

@@ -1,82 +0,0 @@
-#!/usr/bin/env bash
-
-#
-# This scripts installs boost and protobuf built with clang. This is needed on
-# ubuntu 15.10 when building with clang
-# It will build these in a 'clang' subdirectory that it creates below the directory
-# this script is run from. If a clang directory already exists the script will refuse
-# to run.
-
-if hash lsb_release 2>/dev/null; then
-    if [ $(lsb_release -si) == "Ubuntu" ]; then
-        ubuntu_release=$(lsb_release -sr)
-    fi
-fi
-
-if [ -z "${ubuntu_release}" ]; then
-    echo "System not supported"
-    exit 1
-fi
-
-if ! hash clang 2>/dev/null; then
-    clang_version=3.7
-    if [ ${ubuntu_release} == "16.04" ]; then
-        clang_version=3.8
-    fi
-    sudo apt-get -y install clang-${clang_version}
-    update-alternatives --install /usr/bin/clang clang /usr/bin/clang-${clang_version} 99 clang++
-    hash -r
-    if ! hash clang 2>/dev/null; then
-        echo "Please install clang"
-        exit 1
-    fi
-fi
-
-if [ ${ubuntu_release} != "16.04" ] && [ ${ubuntu_release} != "15.10" ]; then
-    echo "clang specific boost and protobuf not needed"
-    exit 0
-fi
-
-if [ -d clang ]; then
-    echo "clang directory already exists. Cowardly refusing to run"
-    exit 1
-fi
-
-if ! hash wget 2>/dev/null; then
-    sudo apt-get -y install wget
-    hash -r
-    if ! hash wget 2>/dev/null; then
-        echo "Please install wget"
-        exit 1
-    fi
-fi
-
-num_procs=$(lscpu -p | grep -v '^#' | sort -u -t, -k 2,4 | wc -l) # pysical cores
-
-mkdir clang
-pushd clang > /dev/null
-
-# Install protobuf
-pb=protobuf-2.6.1
-pb_tar=${pb}.tar.gz 
-wget -O ${pb_tar} https://github.com/google/protobuf/releases/download/v2.6.1/${pb_tar}
-tar xf ${pb_tar}
-rm ${pb_tar}
-pushd ${pb} > /dev/null
-./configure CC=clang CXX=clang++ CXXFLAGS='-std=c++14 -O3 -g'
-make -j${num_procs}
-popd > /dev/null
-
-# Install boost
-boost_ver=1.60.0
-bd=boost_${boost_ver//./_}
-bd_tar=${bd}.tar.gz
-wget -O ${bd_tar} http://sourceforge.net/projects/boost/files/boost/${boost_ver}/${bd_tar}
-tar xf ${bd_tar}
-rm ${bd_tar}
-pushd ${bd} > /dev/null
-./bootstrap.sh
-./b2 toolset=clang -j${num_procs}
-popd > /dev/null
-
-popd > /dev/null

Builds/Ubuntu/install_boost.sh

@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-
-#
-# This script builds boost with the correct ABI flags for ubuntu
-#
-
-version=63
-patch=0
-
-if hash lsb_release 2>/dev/null; then
-    if [ $(lsb_release -si) == "Ubuntu" ]; then
-        ubuntu_release=$(lsb_release -sr)
-    fi
-fi
-
-if [ -z "${ubuntu_release}" ]; then
-    echo "System not supported"
-    exit 1
-fi
-
-extra_defines=""
-if (( $(bc <<< "${ubuntu_release} < 15.1") )); then
-    extra_defines="define=_GLIBCXX_USE_CXX11_ABI=0"
-fi
-num_procs=$(lscpu -p | grep -v '^#' | sort -u -t, -k 2,4 | wc -l) # pysical cores
-printf "\nBuild command will be: ./b2 -j${num_procs} ${extra_defines}\n\n"
-
-boost_dir="boost_1_${version}_${patch}"
-boost_tag="boost-1.${version}.${patch}"
-git clone -b "${boost_tag}" --recursive https://github.com/boostorg/boost.git "${boost_dir}"
-
-cd ${boost_dir}
-git checkout --force ${boost_tag}
-git submodule foreach git checkout --force ${boost_tag}
-./bootstrap.sh
-./b2 headers
-./b2 -j${num_procs} ${extra_defines}
-echo "Build command was: ./b2 -j${num_procs} ${extra_defines}"
-echo "Don't forget to set BOOST_ROOT!"

Builds/Ubuntu/install_rippled_depends_ubuntu.sh

@@ -1,59 +0,0 @@
-#!/usr/bin/env bash
-
-#
-# This scripts installs the dependencies needed by rippled. It should be run
-# with sudo. For ubuntu < 15.10, it installs gcc 5 as the default compiler. gcc
-# 5 is ABI incompatable with gcc 4. If needed, the following will switch back to
-# gcc-4: `sudo update-alternatives --config gcc` and choosing the gcc-4
-# option.
-#
-
-if hash lsb_release 2>/dev/null; then
-    if [ $(lsb_release -si) == "Ubuntu" ]; then
-        ubuntu_release=$(lsb_release -sr)
-    fi
-fi
-
-if [ -z "${ubuntu_release}" ]; then
-    echo "System not supported"
-    exit 1
-fi
-
-if [ ${ubuntu_release} == "12.04" ]; then
-    apt-get install python-software-properties
-    add-apt-repository ppa:afrank/boost
-    add-apt-repository ppa:ubuntu-toolchain-r/test
-    apt-get update
-    apt-get -y upgrade
-    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost1.57-all-dev g++-5 g++-4.9
-    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99 --slave /usr/bin/g++ g++ /usr/bin/g++-5
-    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
-    exit 0
-fi
-
-if [ ${ubuntu_release} == "14.04" ] || [ ${ubuntu_release} == "15.04" ]; then
-    apt-get install python-software-properties
-    echo "deb [arch=amd64] https://mirrors.ripple.com/ubuntu/ trusty stable contrib" | sudo tee /etc/apt/sources.list.d/ripple.list
-    wget -O- -q https://mirrors.ripple.com/mirrors.ripple.com.gpg.key | sudo apt-key add -
-    add-apt-repository ppa:ubuntu-toolchain-r/test
-    apt-get update
-    apt-get -y upgrade
-    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost-all-dev g++-5 g++-4.9
-    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99 --slave /usr/bin/g++ g++ /usr/bin/g++-5
-    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
-    exit 0
-fi
-
-# Test if 0th parameter has a version number greater than or equal to the 1st param
-function version_check() { test "$(printf '%s\n' "$@" | sort -V | tail -n 1)" == "$1"; }
-
-# this should work for versions greater than 15.10
-if version_check ${ubuntu_release} 15.10; then
-    apt-get update
-    apt-get -y upgrade
-    apt-get -y install python-software-properties curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties libboost-all-dev
-    exit 0
-fi
-
-echo "System not supported"
-exit 1

Builds/VisualStudio2015/.gitattributes

@@ -1,4 +0,0 @@
-RippleD.vcxproj             -text
-RippleD.vcxproj.filters     -text
-
-

Builds/VisualStudio2015/README.md

@@ -1,255 +0,0 @@
-# Visual Studio 2015 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:
-
-* [Visual Studio 2015](README.md#install-visual-studio-2015)
-* [Git for Windows](README.md#install-git-for-windows)
-* [Google Protocol Buffers Compiler](README.md#install-google-protocol-buffers-compiler)
-* (Optional) [Python and Scons](README.md#optional-install-python-and-scons)
-* [OpenSSL Library](README.md#install-openssl)
-* [Boost library](README.md#build-boost)
-
-## Install Software
-
-### Install Visual Studio 2015
-
-If not already installed on your system, download your choice of installer from the
-[Visual Studio 2015 Download](https://www.visualstudio.com/downloads/download-visual-studio-vs)
-page, run the installer, and follow the directions. You may need to choose a "Custom"
-installation and ensure that "Visual C++" is selected under "Programming Languages".
-
-Any version of Visual Studio 2015 may be used to build rippled.
-The **Visual Studio 2015 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 free initial 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.
-
-* NOTE: To gain full featured access to the
-  [git-subtree](https://blogs.atlassian.com/2013/05/alternatives-to-git-submodule-git-subtree/)
-  functionality used in the rippled repository we suggest Git version 2.6.2 or later.
-
-### Install Google Protocol Buffers Compiler
-
-Building rippled requires **protoc.exe** version 2.5.1 or later. 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 folder 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.
-
-### (Optional) Install Python and Scons
-
-[Python](https://www.python.org/downloads/) and
-[Scons](http://scons.org/download.php) are not required to build
-rippled with Visual Studio, but can be used to build from the
-command line and in scripts, and are required to properly update
-the `RippleD.vcxproj` file.
-
-If you wish to build with scons, a version after 2.3.5 is required
-for Visual Studio 2015 support.
-
-## Configure Dependencies
-
-### Install OpenSSL
-
-[Download OpenSSL.](http://slproweb.com/products/Win32OpenSSL.html)
-There will be four variants available:
-
-1. 64-bit. Use this if you are running 64-bit windows. As of this writing, the link is called: "Win64 OpenSSL v1.0.2j".
-2. 64-bit light - Don't use this. It is missing files needed to build rippled. As of this writing, the link is called: "Win64 OpenSSL v1.0.2j 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, open a **Developer Command Prompt** for
-Visual Studio, change to the directory containing boost, then
-bootstrap the build tools:
-
-(As of this writing, the most recent version of boost is 1.62.0, which
-will unpack into a directory named `boost_1_62_0`. For higher versions
-of boost, adjust the directories provided in these examples as
-appropriate.)
-
-```powershell
-cd C:\lib\boost_1_62_0
-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 --toolset=msvc-14.0 address-model=64 architecture=x86 link=static threading=multi runtime-link=shared,static stage --stagedir=stage64
-```
-
-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.
-
-* NOTE: If older versions of Visual Studio are also installed, the build may fail.
-  If this happens, make sure that only Visual Studio 2015 is installed. Due to
-  defects in the uninstallation procedures of these Microsoft products, it may
-  be necessary to start with a fresh install of the operating system with only
-  the necessary development environment components installed to have a successful build.
-
-### 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
-git checkout master
-```
-
-* If you receive an error about not having the "correct access rights"
-  make sure you have Github ssh keys, as described above.
-
-### Configure Library Paths
-
-Open the solution file located at **Builds/Visual Studio 2015/ripple.sln**
-and select the "View->Property Manager" to bring up the Property Manager.
-Expand the *debug | x64* section and
-double click the *Microsoft.Cpp.x64.user* property sheet to bring up the
-*Property Pages* dialog. These are global properties applied to all
-64-bit build targets:
-
-![Visual Studio 2015 Global Properties](images/VS2015x64Properties.png)
-
-Go to *C/C++, General, Additional Include Directories* and add the
-location of the boost installation:
-
-![Visual Studio 2015 Include Directories](images/VS2015x64IncludeDirs.png)
-
-Then, go to *Linker, General, Additional Library Directories* and add
-the location of the compiled boost libraries reported at the completion
-of building the boost libraries:
-
-![Visual Studio 2015 Library Directories](images/VS2015x64LibraryDirs.png)
-
-Follow the same procedure for adding the `Additional Include Directories`
-and `Additional Library Directories` required for OpenSSL. In our example
-these directories are **C:\lib\OpenSSL-Win64\include** and
-**C:\lib\OpenSSL-Win64\lib** respectively.
-
-# Setup Environment
-
-## Create a working directory for rippled.cfg
-
-The rippled server uses the [Rippled.cfg](https://wiki.ripple.com/Rippled.cfg)
-file to read its configuration parameters. This section describes setting up
-a directory to hold the config file. The next sections describe how to tell
-the rippled server where that file is.
-
-1. Create a directory to hold the configuration file. In this example, the
-  ripple config directory was created in `C:\Users\joe\ripple\config`.
-2. Copy the example config file located in `doc\rippled-example.cfg` to the
-  new directory and rename it "rippled.cfg".
-3. Read the rippled.cfg file and edit as appropriate.
-
-## Change the Visual Studio Projects Debugging Properties
-
-1. If not already open, open the solution file located at **Builds/Visual Studio 2015/Ripple.sln**
-2. Select the correct solution platform in the solution platform dropdown (either *x64*
-  or *Win32* depending on machine type).
-3. Select the "Project->Properties" menu item to bring up RippleD's Properties Pages
-4. In "Configuration Properties" select "Debugging".
-5. In the upper-left Configurations drop down, select "All Configurations".
-6. In "Debugger to Launch" select "Local Windows Debugger".
-
-### Tell rippled where to find the configuration file.
-
-The `--conf` command-line switch to tell rippled where to find this file.
-In the "Command Arguments" field in the properties dialog (that you opened
-in the above section), add: `--conf="C:/Users/joe/ripple/config/rippled.cfg"`
-(of course replacing that path with the path you set up above).
-
-![Visual Studio 2013 Command Args Prop Page](images/VSCommandArgsPropPage.png)
-
-### Set the _NO_DEBUG_HEAP Environment Variable
-
-Rippled can run very slowly in the debugger when using the Windows Debug Heap.
-Set the `_NO_DEBUG_HEAP` environment variable to one to disable the debug heap.
-In the "Environment" field (that you opened in the above section), add:
-`_NO_DEBUG_HEAP=1`
-
-![Visual Studio 2013 No Debug Heap Prop Page](images/NoDebugHeapPropPage.png)
-
-# Build
-
-After these steps are complete, rippled should be ready to build. Simply
-set rippled as the startup project by right clicking on it in the
-Visual Studio Solution Explorer, choose **Set as Startup Project**,
-and then choose the **Build->Build Solution** menu item.
-
-# Unit Tests (Recommended)
-
-The rippled unit tests are written in C++ and are part
-of the rippled executable.
-
-From a Windows console, run the unit tests:
-
-```
-./build/msvc.debug/rippled.exe --unittest
-```
-
-Substitute the correct path to the executable to test different builds.
-
-

Builds/VisualStudio2015/ripple.sln

@@ -1,36 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25123.0
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RippleD", "RippleD.vcxproj", "{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		debug.classic|x64 = debug.classic|x64
-		debug.classic|x86 = debug.classic|x86
-		debug|x64 = debug|x64
-		debug|x86 = debug|x86
-		release.classic|x64 = release.classic|x64
-		release.classic|x86 = release.classic|x86
-		release|x64 = release|x64
-		release|x86 = release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug.classic|x64.ActiveCfg = debug.classic|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug.classic|x64.Build.0 = debug.classic|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug.classic|x86.ActiveCfg = debug.classic|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug|x64.ActiveCfg = debug|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug|x64.Build.0 = debug|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.debug|x86.ActiveCfg = debug|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release.classic|x64.ActiveCfg = release.classic|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release.classic|x64.Build.0 = release.classic|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release.classic|x86.ActiveCfg = release.classic|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release|x64.ActiveCfg = release|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release|x64.Build.0 = release|x64
-		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.release|x86.ActiveCfg = release|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

Builds/XCode/README.md

@@ -1,177 +0,0 @@
-# macos Build Instructions
-
-## Important
-
-We don't recommend OS X for rippled production use at this time. Currently, the
-Ubuntu platform has received the highest level of quality assurance and
-testing.
-
-## Prerequisites
-
-You'll need OSX 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/)
-* [Git](http://git-scm.com/)
-* [Scons](http://www.scons.org/)
-
-## 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 3: Install Homebrew"
-[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
-
-### Install Git
-
-```
-brew update brew install git
-```
-
-For more info, see "Step 4: Install Git"
-[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
-
-**NOTE**: To gain full featured access to the
-[git-subtree](http://blogs.atlassian.com/2013/05/alternatives-to-git-submodule-git-subtree/)
-functionality used in the rippled repository, we suggest Git version 1.8.3.2 or
-later.
-
-### Install Scons
-
-Requires version 2.3.0 or later
-
-```
-brew install scons
-```
-
-`brew` will generally install the latest stable version of any package, which
-will satisfy the scons minimum version requirement for rippled.
-
-### Install Package Config
-
-```
-brew install pkg-config
-```
-
-## Install/Build/Configure Dependencies
-
-### Build Google Protocol Buffers Compiler
-
-Building rippled on osx requires `protoc` version 2.5.x or 2.6.x (later versions
-do not work with rippled at this time).
-
-Download [this](https://github.com/google/protobuf/releases/download/v2.6.1/protobuf-2.6.1.tar.bz2)
-
-We want to compile protocol buffers with clang/libc++:
-
-```
-tar xfvj protobuf-2.6.1.tar.bz2
-cd protobuf-2.6.1
-./configure CC=clang CXX=clang++ CXXFLAGS='-std=c++11 -stdlib=libc++ -O3 -g' LDFLAGS='-stdlib=libc++' LIBS="-lc++ -lc++abi"
-make -j 4
-sudo make install
-```
-
-If you have installed `protobuf` via brew - either directly or indirectly as a
-dependency of some other package - this is likely to conflict with our specific
-version requirements. The simplest way to avoid conflicts is to uninstall it.
-`brew ls --versions protobuf` will list any versions of protobuf
-you currently have installed.
-
-### Install OpenSSL
-
-```
-brew install openssl
-```
-
-### Build Boost
-
-We want to compile boost with clang/libc++
-
-Download [a release](https://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.tar.bz2)
-
-Extract it to a folder, making note of where, open a terminal, then:
-
-```
-./bootstrap.sh ./b2 toolset=clang threading=multi runtime-link=static link=static cxxflags="-stdlib=libc++" linkflags="-stdlib=libc++" address-model=64
-```
-
-Create an environment variable `BOOST_ROOT` in one of your `rc` files, pointing
-to the root of the extracted directory.
-
-### Clone the rippled repository
-
-From the terminal
-
-```
-git clone git@github.com:ripple/rippled.git
-cd rippled
-```
-
-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
-```
-
-### 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.61.0 in `/Users/Abigail/Downloads/boost_1_61_0`, you would do for any
-shell in which you want to build:
-
-```
-export BOOST_ROOT=/Users/Abigail/Downloads/boost_1_61_0
-```
-
-## Build
-
-```
-scons
-```
-
-See: [here](https://ripple.com/wiki/Rippled_build_instructions#Building)
-
-## 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 after running the unit tests.
-
-

Builds/build_all.sh

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

Builds/containers/README.md

@@ -0,0 +1,31 @@
+
+# rippled Packaging and Containers
+
+This folder contains docker container definitions and configuration
+files to support building rpm and deb packages of rippled. The container
+definitions include some additional software/packages that are used
+for general build/test CI workflows of rippled but are not explicitly
+needed for the package building workflow.
+
+## CMake Targets
+
+If you have docker installed on your local system, then the main 
+CMake file will enable several targets related to building packages:
+`rpm_container`, `rpm`, `dpkg_container`, and `dpkg`. The package targets
+depend on the container targets and will trigger a build of those first.
+The container builds can take several dozen minutes to complete (depending
+on hardware specs), so quick build cycles are not possible currently. As
+such, these targets are often best suited to CI/automated build systems.
+
+The package build can be invoked like any other cmake target from the 
+rippled root folder:
+```
+mkdir -p build/pkg && cd build/pkg
+cmake -Dpackages_only=ON ../..
+cmake --build . --target rpm
+```
+Upon successful completion, the generated package files will be in 
+the `build/pkg/packages` directory. For deb packages, simply replace
+`rpm` with `dpkg` in the build command above.
+
+

Builds/containers/centos-builder/Dockerfile

@@ -0,0 +1,26 @@
+FROM rippleci/centos:7
+ARG GIT_COMMIT=unknown
+ARG CI_USE=false
+
+LABEL git-commit=$GIT_COMMIT
+
+COPY centos-builder/centos_setup.sh /tmp/
+COPY shared/install_cmake.sh /tmp/
+RUN chmod +x /tmp/centos_setup.sh && \
+    chmod +x /tmp/install_cmake.sh
+RUN /tmp/centos_setup.sh
+
+RUN /tmp/install_cmake.sh 3.16.3 /opt/local/cmake-3.16
+RUN ln -s /opt/local/cmake-3.16 /opt/local/cmake
+ENV PATH="/opt/local/cmake/bin:$PATH"
+# TODO: Install latest CMake for testing
+RUN if [ "${CI_USE}" = true ] ; then /tmp/install_cmake.sh 3.16.3 /opt/local/cmake-3.16; fi
+
+RUN mkdir -m 777 -p /opt/rippled_bld/pkg
+
+WORKDIR /opt/rippled_bld/pkg
+RUN mkdir -m 777 ./rpmbuild
+RUN mkdir -m 777 ./rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
+
+COPY packaging/rpm/build_rpm.sh ./
+CMD ./build_rpm.sh

Builds/containers/centos-builder/centos_setup.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -ex
+
+source /etc/os-release
+
+yum -y upgrade
+yum -y update
+yum -y install epel-release centos-release-scl
+yum -y install \
+    wget curl time gcc-c++ yum-utils autoconf automake pkgconfig libtool \
+    libstdc++-static rpm-build gnupg which make cmake \
+    devtoolset-11 devtoolset-11-gdb devtoolset-11-binutils devtoolset-11-libstdc++-devel \
+    devtoolset-11-libasan-devel devtoolset-11-libtsan-devel devtoolset-11-libubsan-devel devtoolset-11-liblsan-devel \
+    flex flex-devel bison bison-devel parallel \
+    ncurses ncurses-devel ncurses-libs graphviz graphviz-devel \
+    lzip p7zip bzip2 bzip2-devel lzma-sdk lzma-sdk-devel xz-devel \
+    zlib zlib-devel zlib-static texinfo openssl openssl-static \
+    jemalloc jemalloc-devel \
+    libicu-devel htop \
+    rh-python38 \
+    ninja-build git svn \
+    swig perl-Digest-MD5

Builds/containers/gitlab-ci/build_container.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env sh
+set -ex
+pkgtype=$1
+if [ "${pkgtype}" = "rpm" ] ; then
+    container_name="${RPM_CONTAINER_NAME}"
+elif [ "${pkgtype}" = "dpkg" ] ; then
+    container_name="${DPKG_CONTAINER_NAME}"
+else
+    echo "invalid package type"
+    exit 1
+fi
+
+if docker pull "${ARTIFACTORY_HUB}/${container_name}:latest_${CI_COMMIT_REF_SLUG}"; then
+    echo "found container for latest - using as cache."
+    docker tag \
+       "${ARTIFACTORY_HUB}/${container_name}:latest_${CI_COMMIT_REF_SLUG}" \
+       "${container_name}:latest_${CI_COMMIT_REF_SLUG}"
+    CMAKE_EXTRA="-D${pkgtype}_cache_from=${container_name}:latest_${CI_COMMIT_REF_SLUG}"
+fi
+
+cmake --version
+test -d build && rm -rf build
+mkdir -p build/container && cd build/container
+eval time \
+    cmake -Dpackages_only=ON -DCMAKE_VERBOSE_MAKEFILE=ON ${CMAKE_EXTRA} \
+    -G Ninja ../..
+time cmake --build . --target "${pkgtype}_container" -- -v
+

Builds/containers/gitlab-ci/build_package.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env sh
+set -ex
+pkgtype=$1
+if [ "${pkgtype}" = "rpm" ] ; then
+    container_name="${RPM_CONTAINER_FULLNAME}"
+    container_tag="${RPM_CONTAINER_TAG}"
+elif [ "${pkgtype}" = "dpkg" ] ; then
+    container_name="${DPKG_CONTAINER_FULLNAME}"
+    container_tag="${DPKG_CONTAINER_TAG}"
+else
+    echo "invalid package type"
+    exit 1
+fi
+time docker pull "${ARTIFACTORY_HUB}/${container_name}"
+docker tag \
+  "${ARTIFACTORY_HUB}/${container_name}" \
+  "${container_name}"
+docker images
+test -d build && rm -rf build
+mkdir -p build/${pkgtype} && cd build/${pkgtype}
+time cmake \
+  -Dpackages_only=ON \
+  -Dcontainer_label="${container_tag}" \
+  -Dhave_package_container=ON \
+  -DCMAKE_VERBOSE_MAKEFILE=ON \
+  -Dunity=OFF \
+  -G Ninja ../..
+time cmake --build . --target ${pkgtype} -- -v

Builds/containers/gitlab-ci/docker_alpine_setup.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env sh
+set -e
+# used as a before/setup script for docker steps in gitlab-ci
+# expects to be run in standard alpine/dind image
+echo $(nproc)
+docker login -u rippled \
+    -p ${ARTIFACTORY_DEPLOY_KEY_RIPPLED} ${ARTIFACTORY_HUB}
+apk add --update py-pip
+apk add \
+    bash util-linux coreutils binutils grep \
+    make ninja cmake build-base gcc g++ abuild git \
+    python3 python3-dev
+pip3 install awscli --break-system-packages
+# list curdir contents to build log:
+ls -la

Builds/containers/gitlab-ci/get_component.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env sh
+case ${CI_COMMIT_REF_NAME} in
+    develop)
+        export COMPONENT="nightly"
+        ;;
+    release)
+        export COMPONENT="unstable"
+        ;;
+    master)
+        export COMPONENT="stable"
+        ;;
+    *)
+        export COMPONENT="_unknown_"
+        ;;
+esac
+

Builds/containers/gitlab-ci/pkgbuild.yml

@@ -0,0 +1,771 @@
+#########################################################################
+##                                                                     ##
+##  gitlab CI defintition for rippled build containers and distro      ##
+##  packages (rpm and dpkg).                                           ##
+##                                                                     ##
+#########################################################################
+
+# NOTE: these are sensible defaults for Ripple pipelines. These
+# can be overridden by project or group variables as needed.
+variables:
+  # these containers are built manually using the rippled
+  # cmake build (container targets) and tagged/pushed so they
+  # can be used here
+  RPM_CONTAINER_TAG: "2023-02-13"
+  RPM_CONTAINER_NAME: "rippled-rpm-builder"
+  RPM_CONTAINER_FULLNAME: "${RPM_CONTAINER_NAME}:${RPM_CONTAINER_TAG}"
+  DPKG_CONTAINER_TAG: "2023-07-31"
+  DPKG_CONTAINER_NAME: "rippled-dpkg-builder"
+  DPKG_CONTAINER_FULLNAME: "${DPKG_CONTAINER_NAME}:${DPKG_CONTAINER_TAG}"
+  ARTIFACTORY_HOST: "artifactory.ops.ripple.com"
+  ARTIFACTORY_HUB: "${ARTIFACTORY_HOST}:6555"
+  GIT_SIGN_PUBKEYS_URL: "https://gitlab.ops.ripple.com/xrpledger/rippled-packages/snippets/49/raw"
+  PUBLIC_REPO_ROOT: "https://repos.ripple.com/repos"
+  # also need to define this variable ONLY for the primary
+  # build/publish pipeline on the mainline repo:
+  #   IS_PRIMARY_REPO = "true"
+
+stages:
+  - build_packages
+  - sign_packages
+  - smoketest
+  - verify_sig
+  - tag_images
+  - push_to_test
+  - verify_from_test
+  - wait_approval_prod
+  - push_to_prod
+  - verify_from_prod
+  - get_final_hashes
+  - build_containers
+
+.dind_template: &dind_param
+  before_script:
+    - . ./Builds/containers/gitlab-ci/docker_alpine_setup.sh
+  variables:
+    docker_driver: overlay2
+    DOCKER_TLS_CERTDIR: ""
+  image:
+    name: artifactory.ops.ripple.com/docker:latest
+  services:
+    # workaround for TLS issues - consider going back
+    # back to unversioned `dind` when issues are resolved
+    - name: artifactory.ops.ripple.com/docker:stable-dind
+      alias: docker
+  tags:
+    - 4xlarge
+
+.only_primary_template: &only_primary
+  only:
+    refs:
+      - /^(master|release|develop)$/
+    variables:
+      - $IS_PRIMARY_REPO == "true"
+
+.smoketest_local_template: &run_local_smoketest
+  tags:
+    - xlarge
+  script:
+    - . ./Builds/containers/gitlab-ci/smoketest.sh local
+
+.smoketest_repo_template: &run_repo_smoketest
+  tags:
+    - xlarge
+  script:
+    - . ./Builds/containers/gitlab-ci/smoketest.sh repo
+
+#########################################################################
+##                                                                     ##
+##  stage: build_packages                                              ##
+##                                                                     ##
+##  build packages using containers from previous stage.               ##
+##                                                                     ##
+#########################################################################
+
+rpm_build:
+  timeout: "1h 30m"
+  stage: build_packages
+  <<: *dind_param
+  artifacts:
+    paths:
+      - build/rpm/packages/
+  script:
+    - . ./Builds/containers/gitlab-ci/build_package.sh rpm
+
+dpkg_build:
+  timeout: "1h 30m"
+  stage: build_packages
+  <<: *dind_param
+  artifacts:
+    paths:
+      - build/dpkg/packages/
+  script:
+    - . ./Builds/containers/gitlab-ci/build_package.sh dpkg
+
+#########################################################################
+##                                                                     ##
+##  stage: sign_packages                                               ##
+##                                                                     ##
+##  build packages using containers from previous stage.               ##
+##                                                                     ##
+#########################################################################
+
+rpm_sign:
+  stage: sign_packages
+  dependencies:
+    - rpm_build
+  image:
+    name: artifactory.ops.ripple.com/centos:7
+  <<: *only_primary
+  before_script:
+  - |
+    # Make sure GnuPG is installed
+    yum -y install gnupg rpm-sign
+    # checking GPG signing support
+    if [ -n "$GPG_KEY_B64" ]; then
+      echo "$GPG_KEY_B64"| base64 -d | gpg --batch --no-tty --allow-secret-key-import --import -
+      unset GPG_KEY_B64
+      export GPG_PASSPHRASE=$(echo $GPG_KEY_PASS_B64 | base64 -di)
+      unset GPG_KEY_PASS_B64
+      export GPG_KEYID=$(gpg --with-colon --list-secret-keys | head -n1 | cut -d : -f 5)
+    else
+      echo -e "\033[0;31m****** GPG signing disabled ******\033[0m"
+      exit 1
+    fi
+  artifacts:
+    paths:
+      - build/rpm/packages/
+  script:
+    - ls -alh build/rpm/packages
+    - . ./Builds/containers/gitlab-ci/sign_package.sh rpm
+
+dpkg_sign:
+  stage: sign_packages
+  dependencies:
+    - dpkg_build
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:18.04
+  <<: *only_primary
+  before_script:
+  - |
+    # make sure we have GnuPG
+    apt update
+    apt install -y gpg dpkg-sig
+    # checking GPG signing support
+    if [ -n "$GPG_KEY_B64" ]; then
+      echo "$GPG_KEY_B64"| base64 -d | gpg --batch --no-tty --allow-secret-key-import --import -
+      unset GPG_KEY_B64
+      export GPG_PASSPHRASE=$(echo $GPG_KEY_PASS_B64 | base64 -di)
+      unset GPG_KEY_PASS_B64
+      export GPG_KEYID=$(gpg --with-colon --list-secret-keys | head -n1 | cut -d : -f 5)
+    else
+      echo -e "\033[0;31m****** GPG signing disabled ******\033[0m"
+      exit 1
+    fi
+  artifacts:
+    paths:
+      - build/dpkg/packages/
+  script:
+    - ls -alh build/dpkg/packages
+    - . ./Builds/containers/gitlab-ci/sign_package.sh dpkg
+
+#########################################################################
+##                                                                     ##
+##  stage: smoketest                                                   ##
+##                                                                     ##
+##  install unsigned packages from previous step and run unit tests.   ##
+##                                                                     ##
+#########################################################################
+
+centos_7_smoketest:
+  stage: smoketest
+  dependencies:
+    - rpm_build
+  image:
+    name: artifactory.ops.ripple.com/centos:7
+  <<: *run_local_smoketest
+
+rocky_8_smoketest:
+  stage: smoketest
+  dependencies:
+    - rpm_build
+  image:
+    name: artifactory.ops.ripple.com/rockylinux/rockylinux:8
+  <<: *run_local_smoketest
+
+rocky_9_smoketest:
+  stage: smoketest
+  dependencies:
+    - rpm_build
+  image:
+    name: artifactory.ops.ripple.com/rockylinux/rockylinux:9
+
+  <<: *run_local_smoketest
+
+alma_8_smoketest:
+  stage: smoketest
+  dependencies:
+    - rpm_build
+  image:
+    name: artifactory.ops.ripple.com/almalinux:8
+  <<: *run_local_smoketest
+
+alma_9_smoketest:
+  stage: smoketest
+  dependencies:
+    - rpm_build
+  image:
+    name: artifactory.ops.ripple.com/almalinux:9
+
+  <<: *run_local_smoketest
+
+fedora_38_smoketest:
+  stage: smoketest
+  dependencies:
+    - rpm_build
+  image:
+    name: artifactory.ops.ripple.com/fedora:38
+  <<: *run_local_smoketest
+
+fedora_39_smoketest:
+  stage: smoketest
+  dependencies:
+    - rpm_build
+  image:
+    name: artifactory.ops.ripple.com/fedora:39
+  <<: *run_local_smoketest
+
+ubuntu_18_smoketest:
+  stage: smoketest
+  dependencies:
+    - dpkg_build
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:18.04
+  <<: *run_local_smoketest
+
+ubuntu_20_smoketest:
+  stage: smoketest
+  dependencies:
+    - dpkg_build
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:20.04
+  <<: *run_local_smoketest
+
+ubuntu_22_smoketest:
+  stage: smoketest
+  dependencies:
+    - dpkg_build
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:22.04
+  <<: *run_local_smoketest
+
+debian_10_smoketest:
+  stage: smoketest
+  dependencies:
+    - dpkg_build
+  image:
+    name: artifactory.ops.ripple.com/debian:10
+  <<: *run_local_smoketest
+
+debian_11_smoketest:
+  stage: smoketest
+  dependencies:
+    - dpkg_build
+  image:
+    name: artifactory.ops.ripple.com/debian:11
+  <<: *run_local_smoketest
+
+debian_12_smoketest:
+  stage: smoketest
+  dependencies:
+    - dpkg_build
+  image:
+    name: artifactory.ops.ripple.com/debian:12
+  <<: *run_local_smoketest
+
+#########################################################################
+##                                                                     ##
+##  stage: verify_sig                                                  ##
+##                                                                     ##
+##  use git/gpg to verify that HEAD is signed by an approved           ##
+##  committer. The whitelist of pubkeys is manually mantained          ##
+##  and fetched from GIT_SIGN_PUBKEYS_URL (currently a snippet         ##
+##  link).                                                             ##
+##  ONLY RUNS FOR PRIMARY BRANCHES/REPO                                ##
+##                                                                     ##
+#########################################################################
+
+verify_head_signed:
+  stage: verify_sig
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:latest
+  <<: *only_primary
+  script:
+    - . ./Builds/containers/gitlab-ci/verify_head_commit.sh
+
+#########################################################################
+##                                                                     ##
+##  stage: tag_images                                                  ##
+##                                                                     ##
+##  apply rippled version tag to containers from previous stage.       ##
+##  ONLY RUNS FOR PRIMARY BRANCHES/REPO                                ##
+##                                                                     ##
+#########################################################################
+
+tag_bld_images:
+  stage: tag_images
+  variables:
+    docker_driver: overlay2
+    DOCKER_TLS_CERTDIR: ""
+  image:
+    name: artifactory.ops.ripple.com/docker:latest
+  services:
+    # workaround for TLS issues - consider going back
+    # back to unversioned `dind` when issues are resolved
+    - name: artifactory.ops.ripple.com/docker:stable-dind
+      alias: docker
+  tags:
+    - large
+  dependencies:
+    - rpm_sign
+    - dpkg_sign
+  <<: *only_primary
+  script:
+    - . ./Builds/containers/gitlab-ci/tag_docker_image.sh
+
+#########################################################################
+##                                                                     ##
+##  stage: push_to_test                                                ##
+##                                                                     ##
+##  push packages to artifactory repositories (test)                   ##
+##  ONLY RUNS FOR PRIMARY BRANCHES/REPO                                ##
+##                                                                     ##
+#########################################################################
+
+push_test:
+  stage: push_to_test
+  variables:
+    DEB_REPO: "rippled-deb-test-mirror"
+    RPM_REPO: "rippled-rpm-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/alpine:latest
+  artifacts:
+    paths:
+      - files.info
+  dependencies:
+    - rpm_sign
+    - dpkg_sign
+  <<: *only_primary
+  script:
+    - . ./Builds/containers/gitlab-ci/push_to_artifactory.sh "PUT" "."
+
+#########################################################################
+##                                                                     ##
+##  stage: verify_from_test                                            ##
+##                                                                     ##
+##  install/test packages from test repos.                             ##
+##  ONLY RUNS FOR PRIMARY BRANCHES/REPO                                ##
+##                                                                     ##
+#########################################################################
+
+centos_7_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    RPM_REPO: "rippled-rpm-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/centos:7
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+rocky_8_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    RPM_REPO: "rippled-rpm-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/rockylinux/rockylinux:8
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+rocky_9_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    RPM_REPO: "rippled-rpm-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/rockylinux/rockylinux:9
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+almalinux_8_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    RPM_REPO: "rippled-rpm-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/almalinux:8
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+almalinux_9_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    RPM_REPO: "rippled-rpm-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/almalinux:9
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+fedora_38_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    RPM_REPO: "rippled-rpm-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/fedora:38
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+fedora_39_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    RPM_REPO: "rippled-rpm-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/fedora:39
+
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+ubuntu_18_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    DISTRO: "bionic"
+    DEB_REPO: "rippled-deb-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:18.04
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+ubuntu_20_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    DISTRO: "focal"
+    DEB_REPO: "rippled-deb-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:20.04
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+ubuntu_22_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    DISTRO: "jammy"
+    DEB_REPO: "rippled-deb-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:22.04
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+debian_10_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    DISTRO: "buster"
+    DEB_REPO: "rippled-deb-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/debian:10
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+debian_11_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    DISTRO: "bullseye"
+    DEB_REPO: "rippled-deb-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/debian:11
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+debian_12_verify_repo_test:
+  stage: verify_from_test
+  variables:
+    DISTRO: "bookworm"
+    DEB_REPO: "rippled-deb-test-mirror"
+  image:
+    name: artifactory.ops.ripple.com/debian:12
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+#########################################################################
+##                                                                     ##
+##  stage: wait_approval_prod                                          ##
+##                                                                     ##
+##  wait for manual approval before proceeding to next stage           ##
+##  which pushes to prod repo.                                         ##
+##  ONLY RUNS FOR PRIMARY BRANCHES/REPO                                ##
+##                                                                     ##
+#########################################################################
+wait_before_push_prod:
+  stage: wait_approval_prod
+  image:
+    name: artifactory.ops.ripple.com/alpine:latest
+  <<: *only_primary
+  script:
+    - echo "proceeding to next stage"
+  when: manual
+  allow_failure: false
+
+#########################################################################
+##                                                                     ##
+##  stage: push_to_prod                                                ##
+##                                                                     ##
+##  push packages to artifactory repositories (prod)                   ##
+##  ONLY RUNS FOR PRIMARY BRANCHES/REPO                                ##
+##                                                                     ##
+#########################################################################
+
+push_prod:
+  variables:
+    DEB_REPO: "rippled-deb"
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/alpine:latest
+  stage: push_to_prod
+  artifacts:
+    paths:
+      - files.info
+  dependencies:
+    - rpm_sign
+    - dpkg_sign
+  <<: *only_primary
+  script:
+    - . ./Builds/containers/gitlab-ci/push_to_artifactory.sh "PUT" "."
+
+#########################################################################
+##                                                                     ##
+##  stage: verify_from_prod                                            ##
+##                                                                     ##
+##  install/test packages from prod repos.                             ##
+##  ONLY RUNS FOR PRIMARY BRANCHES/REPO                                ##
+##                                                                     ##
+#########################################################################
+
+centos_7_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/centos:7
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+rocky_8_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/rockylinux/rockylinux:8
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+rocky_9_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/rockylinux/rockylinux:9
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+alma_8_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/almalinux:8
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+alma_9_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/almalinux:9
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+fedora_37_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/fedora:37
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+fedora_38_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/fedora:38
+  dependencies:
+    - rpm_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+ubuntu_18_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    DISTRO: "bionic"
+    DEB_REPO: "rippled-deb"
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:18.04
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+ubuntu_20_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    DISTRO: "focal"
+    DEB_REPO: "rippled-deb"
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:20.04
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+ubuntu_22_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    DISTRO: "jammy"
+    DEB_REPO: "rippled-deb"
+  image:
+    name: artifactory.ops.ripple.com/ubuntu:22.04
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+debian_10_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    DISTRO: "buster"
+    DEB_REPO: "rippled-deb"
+  image:
+    name: artifactory.ops.ripple.com/debian:10
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+debian_11_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    DISTRO: "bullseye"
+    DEB_REPO: "rippled-deb"
+  image:
+    name: artifactory.ops.ripple.com/debian:11
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+debian_12_verify_repo_prod:
+  stage: verify_from_prod
+  variables:
+    DISTRO: "bookworm"
+    DEB_REPO: "rippled-deb"
+  image:
+    name: artifactory.ops.ripple.com/debian:12
+  dependencies:
+    - dpkg_sign
+  <<: *only_primary
+  <<: *run_repo_smoketest
+
+
+#########################################################################
+##                                                                     ##
+##  stage: get_final_hashes                                            ##
+##                                                                     ##
+##  fetch final hashes from artifactory.                               ##
+##  ONLY RUNS FOR PRIMARY BRANCHES/REPO                                ##
+##                                                                     ##
+#########################################################################
+
+get_prod_hashes:
+  variables:
+    DEB_REPO: "rippled-deb"
+    RPM_REPO: "rippled-rpm"
+  image:
+    name: artifactory.ops.ripple.com/alpine:latest
+  stage: get_final_hashes
+  artifacts:
+    paths:
+      - files.info
+  dependencies:
+    - rpm_sign
+    - dpkg_sign
+  <<: *only_primary
+  script:
+    - . ./Builds/containers/gitlab-ci/push_to_artifactory.sh "GET" ".checksums"
+
+#########################################################################
+##                                                                     ##
+##  stage: build_containers                                            ##
+##                                                                     ##
+##  build containers from docker definitions. These containers are NOT ##
+##  used for the package build. This step is only used to ensure that  ##
+##  the package build targets and files are still working properly.    ##
+##                                                                     ##
+#########################################################################
+
+build_centos_container:
+  stage: build_containers
+  <<: *dind_param
+  script:
+    - . ./Builds/containers/gitlab-ci/build_container.sh rpm
+
+build_ubuntu_container:
+  stage: build_containers
+  <<: *dind_param
+  script:
+    - . ./Builds/containers/gitlab-ci/build_container.sh dpkg

Builds/containers/gitlab-ci/push_to_artifactory.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env sh
+set -e
+action=$1
+filter=$2
+
+. ./Builds/containers/gitlab-ci/get_component.sh
+
+apk add curl jq coreutils util-linux
+TOPDIR=$(pwd)
+
+# DPKG
+
+cd $TOPDIR
+cd build/dpkg/packages
+CURLARGS="-sk -X${action} -urippled:${ARTIFACTORY_DEPLOY_KEY_RIPPLED}"
+RIPPLED_PKG=$(ls rippled_*.deb)
+RIPPLED_REPORTING_PKG=$(ls rippled-reporting_*.deb)
+RIPPLED_DBG_PKG=$(ls rippled-dbgsym_*.*deb)
+RIPPLED_REPORTING_DBG_PKG=$(ls rippled-reporting-dbgsym_*.*deb)
+# TODO - where to upload src tgz?
+RIPPLED_SRC=$(ls rippled_*.orig.tar.gz)
+DEB_MATRIX=";deb.component=${COMPONENT};deb.architecture=amd64"
+for dist in bookworm buster bullseye bionic focal jammy; do
+    DEB_MATRIX="${DEB_MATRIX};deb.distribution=${dist}"
+done
+echo "{ \"debs\": {" > "${TOPDIR}/files.info"
+for deb in ${RIPPLED_PKG} ${RIPPLED_DBG_PKG} ${RIPPLED_REPORTING_PKG} ${RIPPLED_REPORTING_DBG_PKG}; do
+    # first item doesn't get a comma separator
+    if [ $deb != $RIPPLED_PKG ] ; then
+        echo "," >> "${TOPDIR}/files.info"
+    fi
+    echo "\"${deb}\"": | tee -a "${TOPDIR}/files.info"
+    ca="${CURLARGS}"
+    if [ "${action}" = "PUT" ] ; then
+        url="https://${ARTIFACTORY_HOST}/artifactory/${DEB_REPO}/pool/${COMPONENT}/${deb}${DEB_MATRIX}"
+        ca="${ca} -T${deb}"
+    elif [ "${action}" = "GET" ] ; then
+        url="https://${ARTIFACTORY_HOST}/artifactory/api/storage/${DEB_REPO}/pool/${COMPONENT}/${deb}"
+    fi
+    echo "file info request url --> ${url}"
+    eval "curl ${ca} \"${url}\"" | jq -M "${filter}" | tee -a "${TOPDIR}/files.info"
+done
+echo "}," >> "${TOPDIR}/files.info"
+
+# RPM
+
+cd $TOPDIR
+cd build/rpm/packages
+RIPPLED_PKG=$(ls rippled-[0-9]*.x86_64.rpm)
+RIPPLED_DEV_PKG=$(ls rippled-devel*.rpm)
+RIPPLED_DBG_PKG=$(ls rippled-debuginfo*.rpm)
+RIPPLED_REPORTING_PKG=$(ls rippled-reporting*.rpm)
+# TODO - where to upload src rpm ?
+RIPPLED_SRC=$(ls rippled-[0-9]*.src.rpm)
+echo "\"rpms\": {" >> "${TOPDIR}/files.info"
+for rpm in ${RIPPLED_PKG} ${RIPPLED_DEV_PKG} ${RIPPLED_DBG_PKG} ${RIPPLED_REPORTING_PKG}; do
+    # first item doesn't get a comma separator
+    if [ $rpm != $RIPPLED_PKG ] ; then
+        echo "," >> "${TOPDIR}/files.info"
+    fi
+    echo "\"${rpm}\"": | tee -a "${TOPDIR}/files.info"
+    ca="${CURLARGS}"
+    if [ "${action}" = "PUT" ] ; then
+        url="https://${ARTIFACTORY_HOST}/artifactory/${RPM_REPO}/${COMPONENT}/"
+        ca="${ca} -T${rpm}"
+    elif [ "${action}" = "GET" ] ; then
+        url="https://${ARTIFACTORY_HOST}/artifactory/api/storage/${RPM_REPO}/${COMPONENT}/${rpm}"
+    fi
+    echo "file info request url --> ${url}"
+    eval "curl ${ca} \"${url}\"" | jq -M "${filter}" | tee -a "${TOPDIR}/files.info"
+done
+echo "}}" >> "${TOPDIR}/files.info"
+jq '.' "${TOPDIR}/files.info" > "${TOPDIR}/files.info.tmp"
+mv "${TOPDIR}/files.info.tmp" "${TOPDIR}/files.info"
+
+if [ ! -z "${SLACK_NOTIFY_URL}" ] && [ "${action}" = "GET" ] ; then
+    # extract files.info content to variable and sanitize so it can
+    # be interpolated into a slack text field below
+    finfo=$(cat ${TOPDIR}/files.info | sed -e ':a' -e 'N' -e '$!ba' -e 's/\n/\\n/g' | sed -E 's/"/\\"/g')
+    # try posting file info to slack.
+    # can add channel field to payload if the
+    # default channel is incorrect. Get rid of
+    # newlines in payload json since slack doesn't accept them
+    CONTENT=$(tr -d '[\n]' <<JSON
+       payload={
+         "username": "GitlabCI",
+         "text": "The package build for branch \`${CI_COMMIT_REF_NAME}\` is complete. File hashes are: \`\`\`${finfo}\`\`\`",
+         "icon_emoji": ":package:"}
+JSON
+)
+    curl ${SLACK_NOTIFY_URL} --data-urlencode "${CONTENT}"
+fi

Builds/containers/gitlab-ci/sign_package.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+set -eo pipefail
+
+sign_dpkg() {
+  if [ -n "${GPG_KEYID}" ]; then
+    dpkg-sig \
+      -g "--no-tty --digest-algo 'sha512' --passphrase '${GPG_PASSPHRASE}' --pinentry-mode=loopback" \
+			-k "${GPG_KEYID}" \
+			--sign builder \
+			"build/dpkg/packages/*.deb"
+	fi
+}
+
+sign_rpm() {
+  if [ -n "${GPG_KEYID}" ] ; then
+    find build/rpm/packages -name "*.rpm" -exec bash -c '
+	echo "yes" | setsid rpm \
+			--define "_gpg_name ${GPG_KEYID}" \
+			--define "_signature gpg" \
+			--define "__gpg_check_password_cmd /bin/true" \
+			--define "__gpg_sign_cmd %{__gpg} gpg --batch --no-armor --digest-algo 'sha512' --passphrase '${GPG_PASSPHRASE}' --no-secmem-warning -u '%{_gpg_name}' --sign --detach-sign --output %{__signature_filename} %{__plaintext_filename}" \
+			--addsign '{} \;
+	fi
+}
+
+case "${1}" in
+    dpkg)
+        sign_dpkg
+        ;;
+    rpm)
+        sign_rpm
+        ;;
+    *)
+        echo "Usage: ${0} (dpkg|rpm)"
+        ;;
+esac
+

Builds/containers/gitlab-ci/smoketest.sh

@@ -0,0 +1,101 @@
+#!/usr/bin/env sh
+set -e
+install_from=$1
+use_private=${2:-0} # this option not currently needed by any CI scripts,
+                    # reserved for possible future use
+if [ "$use_private" -gt 0 ] ; then
+    REPO_ROOT="https://rippled:${ARTIFACTORY_DEPLOY_KEY_RIPPLED}@${ARTIFACTORY_HOST}/artifactory"
+else
+    REPO_ROOT="${PUBLIC_REPO_ROOT}"
+fi
+
+. ./Builds/containers/gitlab-ci/get_component.sh
+
+. /etc/os-release
+case ${ID} in
+    ubuntu|debian)
+        pkgtype="dpkg"
+        ;;
+    fedora|centos|rhel|scientific|rocky|almalinux)
+        pkgtype="rpm"
+        ;;
+    *)
+        echo "unrecognized distro!"
+        exit 1
+        ;;
+esac
+
+# this script provides info variables about pkg version
+. build/${pkgtype}/packages/build_vars
+
+if [ "${pkgtype}" = "dpkg" ] ; then
+    # sometimes update fails and requires a cleanup
+    updateWithRetry()
+    {
+        if ! apt-get -y update ; then
+            rm -rvf /var/lib/apt/lists/*
+            apt-get -y clean
+            apt-get -y update
+        fi
+    }
+    if [ "${install_from}" = "repo" ] ; then
+        apt-get -y upgrade
+        updateWithRetry
+        apt-get -y install apt apt-transport-https ca-certificates coreutils util-linux wget gnupg
+        wget -q -O - "${REPO_ROOT}/api/gpg/key/public" | apt-key add -
+        echo "deb ${REPO_ROOT}/${DEB_REPO} ${DISTRO} ${COMPONENT}" >> /etc/apt/sources.list
+        updateWithRetry
+        # uncomment this next line if you want to see the available package versions
+        # apt-cache policy rippled
+        apt-get -y install rippled=${dpkg_full_version}
+    elif [ "${install_from}" = "local" ] ; then
+        # cached pkg install
+        updateWithRetry
+        apt-get -y install libprotobuf-dev libprotoc-dev protobuf-compiler libssl-dev
+        rm -f build/dpkg/packages/rippled-dbgsym*.*
+        dpkg --no-debsig -i build/dpkg/packages/*.deb
+    else
+        echo "unrecognized pkg source!"
+        exit 1
+    fi
+else
+    yum -y update
+    if [ "${install_from}" = "repo" ] ; then
+        pkgs=("yum-utils coreutils util-linux")
+        case "$ID" in
+            rocky|almalinux)
+                pkgs="${pkgs[@]/coreutils}"
+        esac
+        yum install -y $pkgs
+        REPOFILE="/etc/yum.repos.d/artifactory.repo"
+        echo "[Artifactory]" > ${REPOFILE}
+        echo "name=Artifactory" >> ${REPOFILE}
+        echo "baseurl=${REPO_ROOT}/${RPM_REPO}/${COMPONENT}/" >> ${REPOFILE}
+        echo "enabled=1" >> ${REPOFILE}
+        echo "gpgcheck=0" >> ${REPOFILE}
+        echo "gpgkey=${REPO_ROOT}/${RPM_REPO}/${COMPONENT}/repodata/repomd.xml.key" >> ${REPOFILE}
+        echo "repo_gpgcheck=1" >> ${REPOFILE}
+        yum -y update
+        # uncomment this next line if you want to see the available package versions
+        # yum --showduplicates list rippled
+        yum -y install ${rpm_version_release}
+    elif [ "${install_from}" = "local" ] ; then
+        rm -f build/rpm/packages/rippled-debug*.rpm
+        rm -f build/rpm/packages/rippled-devel*.rpm
+        rm -f build/rpm/packages/*.src.rpm
+        rpm -i build/rpm/packages/*.rpm
+    else
+        echo "unrecognized pkg source!"
+        exit 1
+    fi
+fi
+
+# verify installed version
+INSTALLED=$(/opt/ripple/bin/rippled --version | awk '{print $NF}')
+if [ "${rippled_version}" != "${INSTALLED}" ] ; then
+    echo "INSTALLED version ${INSTALLED} does not match ${rippled_version}"
+    exit 1
+fi
+# run unit tests
+/opt/ripple/bin/rippled --unittest --unittest-jobs $(nproc)
+/opt/ripple/bin/validator-keys --unittest

Builds/containers/gitlab-ci/tag_docker_image.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env sh
+set -e
+docker login -u rippled \
+    -p ${ARTIFACTORY_DEPLOY_KEY_RIPPLED} "${ARTIFACTORY_HUB}"
+# this gives us rippled_version :
+source build/rpm/packages/build_vars
+docker pull "${ARTIFACTORY_HUB}/${RPM_CONTAINER_FULLNAME}"
+docker pull "${ARTIFACTORY_HUB}/${DPKG_CONTAINER_FULLNAME}"
+# tag/push two labels...one using the current rippled version and one just using "latest"
+for label in ${rippled_version} latest ; do
+    docker tag \
+        "${ARTIFACTORY_HUB}/${RPM_CONTAINER_FULLNAME}" \
+        "${ARTIFACTORY_HUB}/${RPM_CONTAINER_NAME}:${label}_${CI_COMMIT_REF_SLUG}"
+    docker push \
+        "${ARTIFACTORY_HUB}/${RPM_CONTAINER_NAME}:${label}_${CI_COMMIT_REF_SLUG}"
+    docker tag \
+        "${ARTIFACTORY_HUB}/${DPKG_CONTAINER_FULLNAME}" \
+        "${ARTIFACTORY_HUB}/${DPKG_CONTAINER_NAME}:${label}_${CI_COMMIT_REF_SLUG}"
+    docker push \
+        "${ARTIFACTORY_HUB}/${DPKG_CONTAINER_NAME}:${label}_${CI_COMMIT_REF_SLUG}"
+done

Builds/containers/gitlab-ci/verify_head_commit.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env sh
+set -ex
+apt -y update
+DEBIAN_FRONTEND="noninteractive" apt-get -y install tzdata
+apt -y install software-properties-common curl git gnupg
+curl -sk -o rippled-pubkeys.txt "${GIT_SIGN_PUBKEYS_URL}"
+gpg --import rippled-pubkeys.txt
+if git verify-commit HEAD; then
+    echo "git commit signature check passed"
+else
+    echo "git commit signature check failed"
+    git log -n 5 --color \
+        --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an> [%G?]%Creset' \
+        --abbrev-commit
+    exit 1
+fi
+

Builds/containers/packaging/dpkg/build_dpkg.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+set -ex
+
+# make sure pkg source files are up to date with repo
+cd /opt/rippled_bld/pkg
+cp -fpru rippled/Builds/containers/packaging/dpkg/debian/. debian/
+cp -fpu rippled/Builds/containers/shared/rippled*.service debian/
+cp -fpu rippled/Builds/containers/shared/update_sources.sh .
+source update_sources.sh
+
+# Build the dpkg
+
+#dpkg uses - as separator, so we need to change our -bN versions to tilde
+RIPPLED_DPKG_VERSION=$(echo "${RIPPLED_VERSION}" | sed 's!-!~!g')
+# TODO - decide how to handle the trailing/release
+# version here (hardcoded to 1). Does it ever need to change?
+RIPPLED_DPKG_FULL_VERSION="${RIPPLED_DPKG_VERSION}-1"
+git config --global --add safe.directory /opt/rippled_bld/pkg/rippled
+cd /opt/rippled_bld/pkg/rippled
+if [[ -n $(git status --porcelain) ]]; then
+    git status
+    error "Unstaged changes in this repo - please commit first"
+fi
+git archive --format tar.gz --prefix rippled-${RIPPLED_DPKG_VERSION}/ -o ../rippled-${RIPPLED_DPKG_VERSION}.tar.gz HEAD
+cd ..
+# dpkg debmake would normally create this link, but we do it manually
+ln -s ./rippled-${RIPPLED_DPKG_VERSION}.tar.gz rippled_${RIPPLED_DPKG_VERSION}.orig.tar.gz
+tar xvf rippled-${RIPPLED_DPKG_VERSION}.tar.gz
+cd rippled-${RIPPLED_DPKG_VERSION}
+cp -pr ../debian .
+
+# dpkg requires a changelog. We don't currently maintain
+# a useable one, so let's just fake it with our current version
+# TODO : not sure if the "unstable" will need to change for
+# release packages (?)
+NOWSTR=$(TZ=UTC date -R)
+cat << CHANGELOG > ./debian/changelog
+rippled (${RIPPLED_DPKG_FULL_VERSION}) unstable; urgency=low
+
+  * see RELEASENOTES
+
+ -- Ripple Labs Inc. <support@ripple.com>  ${NOWSTR}
+CHANGELOG
+
+# PATH must be preserved for our more modern cmake in /opt/local
+# TODO : consider allowing lintian to run in future ?
+export DH_BUILD_DDEBS=1
+debuild --no-lintian --preserve-envvar PATH --preserve-env -us -uc
+rc=$?; if [[ $rc != 0 ]]; then
+    error "error building dpkg"
+fi
+cd ..
+
+# copy artifacts
+cp rippled-reporting_${RIPPLED_DPKG_FULL_VERSION}_amd64.deb ${PKG_OUTDIR}
+cp rippled_${RIPPLED_DPKG_FULL_VERSION}_amd64.deb ${PKG_OUTDIR}
+cp rippled_${RIPPLED_DPKG_FULL_VERSION}.dsc ${PKG_OUTDIR}
+# dbgsym suffix is ddeb under newer debuild, but just deb under earlier
+cp rippled-dbgsym_${RIPPLED_DPKG_FULL_VERSION}_amd64.* ${PKG_OUTDIR}
+cp rippled-reporting-dbgsym_${RIPPLED_DPKG_FULL_VERSION}_amd64.* ${PKG_OUTDIR}
+cp rippled_${RIPPLED_DPKG_FULL_VERSION}_amd64.changes ${PKG_OUTDIR}
+cp rippled_${RIPPLED_DPKG_FULL_VERSION}_amd64.build ${PKG_OUTDIR}
+cp rippled_${RIPPLED_DPKG_VERSION}.orig.tar.gz ${PKG_OUTDIR}
+cp rippled_${RIPPLED_DPKG_FULL_VERSION}.debian.tar.xz ${PKG_OUTDIR}
+# buildinfo is only generated by later version of debuild
+if [ -e rippled_${RIPPLED_DPKG_FULL_VERSION}_amd64.buildinfo ] ; then
+    cp rippled_${RIPPLED_DPKG_FULL_VERSION}_amd64.buildinfo ${PKG_OUTDIR}
+fi
+
+pushd ${PKG_OUTDIR}
+for f in *.ddeb; do mv -- "$f" "${f%.ddeb}.deb"; done
+popd
+
+cat rippled_${RIPPLED_DPKG_FULL_VERSION}_amd64.changes
+# extract the text in the .changes file that appears between
+#    Checksums-Sha256:  ...
+# and
+#    Files: ...
+awk '/Checksums-Sha256:/{hit=1;next}/Files:/{hit=0}hit' \
+    rippled_${RIPPLED_DPKG_VERSION}-1_amd64.changes | \
+        sed -E 's!^[[:space:]]+!!' > shasums
+DEB_SHA256=$(cat shasums | \
+    grep "rippled_${RIPPLED_DPKG_VERSION}-1_amd64.deb" | cut -d " " -f 1)
+DBG_SHA256=$(cat shasums | \
+    grep "rippled-dbgsym_${RIPPLED_DPKG_VERSION}-1_amd64.*" | cut -d " " -f 1)
+REPORTING_DBG_SHA256=$(cat shasums | \
+    grep "rippled-reporting-dbgsym_${RIPPLED_DPKG_VERSION}-1_amd64.*" | cut -d " " -f 1)
+REPORTING_SHA256=$(cat shasums | \
+    grep "rippled-reporting_${RIPPLED_DPKG_VERSION}-1_amd64.deb" | cut -d " " -f 1)
+SRC_SHA256=$(cat shasums | \
+    grep "rippled_${RIPPLED_DPKG_VERSION}.orig.tar.gz" | cut -d " " -f 1)
+echo "deb_sha256=${DEB_SHA256}" >> ${PKG_OUTDIR}/build_vars
+echo "dbg_sha256=${DBG_SHA256}" >> ${PKG_OUTDIR}/build_vars
+echo "reporting_sha256=${REPORTING_SHA256}" >> ${PKG_OUTDIR}/build_vars
+echo "reporting_dbg_sha256=${REPORTING_DBG_SHA256}" >> ${PKG_OUTDIR}/build_vars
+echo "src_sha256=${SRC_SHA256}" >> ${PKG_OUTDIR}/build_vars
+echo "rippled_version=${RIPPLED_VERSION}" >> ${PKG_OUTDIR}/build_vars
+echo "dpkg_version=${RIPPLED_DPKG_VERSION}" >> ${PKG_OUTDIR}/build_vars
+echo "dpkg_full_version=${RIPPLED_DPKG_FULL_VERSION}" >> ${PKG_OUTDIR}/build_vars

Builds/containers/packaging/dpkg/debian/README.Debian

@@ -0,0 +1,3 @@
+rippled daemon
+
+ -- Mike Ellery <mellery451@gmail.com>  Tue, 04 Dec 2018 18:19:03 +0000

Builds/containers/packaging/dpkg/debian/compat

@@ -0,0 +1 @@
+10

Builds/containers/packaging/dpkg/debian/control

@@ -0,0 +1,19 @@
+Source: rippled
+Section: misc
+Priority: extra
+Maintainer: Ripple Labs Inc. <support@ripple.com>
+Build-Depends: cmake, debhelper (>=9), zlib1g-dev, dh-systemd, ninja-build
+Standards-Version: 3.9.7
+Homepage: http://ripple.com/
+
+Package: rippled
+Architecture: any
+Multi-Arch: foreign
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Description: rippled daemon
+
+Package: rippled-reporting
+Architecture: any
+Multi-Arch: foreign
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Description: rippled reporting daemon

Builds/containers/packaging/dpkg/debian/copyright

@@ -0,0 +1,86 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: rippled
+Source: https://github.com/ripple/rippled 
+
+Files: *
+Copyright: 2012-2019 Ripple Labs Inc.
+
+License:   __UNKNOWN__
+
+The accompanying files under various copyrights.
+
+Copyright (c) 2012, 2013, 2014 Ripple Labs Inc.
+
+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.
+
+The accompanying files incorporate work covered by the following copyright
+and previous license notice:
+
+Copyright (c) 2011 Arthur Britto, David Schwartz, Jed McCaleb,
+Vinnie Falco, Bob Way, Eric Lombrozo, Nikolaos D. Bougalis, Howard Hinnant
+
+Some code from Raw Material Software, Ltd., provided under the terms of the
+  ISC License. See the corresponding source files for more details.
+  Copyright (c) 2013 - Raw Material Software Ltd.
+  Please visit http://www.juce.com
+
+Some code from ASIO examples:
+// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+Some code from Bitcoin:
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+Some code from Tom Wu:
+This software is covered under the following copyright:
+
+/*
+ * Copyright (c) 2003-2005  Tom Wu
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+ *
+ * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+ * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
+ * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * In addition, the following condition applies:
+ *
+ * All redistributions must retain an intact copy of this copyright notice
+ * and disclaimer.
+ */
+
+Address all questions regarding this license to:
+
+  Tom Wu
+  tjw@cs.Stanford.EDU

Builds/containers/packaging/dpkg/debian/dirs

@@ -0,0 +1,3 @@
+/var/log/rippled/
+/var/lib/rippled/
+/etc/systemd/system/rippled.service.d/

Builds/containers/packaging/dpkg/debian/docs

@@ -0,0 +1,3 @@
+README.md
+LICENSE.md
+RELEASENOTES.md

Builds/containers/packaging/dpkg/debian/rippled-dev.install

@@ -0,0 +1,3 @@
+opt/ripple/include
+opt/ripple/lib/*.a
+opt/ripple/lib/cmake/ripple

Builds/containers/packaging/dpkg/debian/rippled-reporting.dirs

@@ -0,0 +1,3 @@
+/var/log/rippled-reporting/
+/var/lib/rippled-reporting/
+/etc/systemd/system/rippled-reporting.service.d/

Builds/containers/packaging/dpkg/debian/rippled-reporting.install

@@ -0,0 +1,8 @@
+build.rippled-reporting/rippled-reporting opt/rippled-reporting/bin
+cfg/rippled-reporting.cfg opt/rippled-reporting/etc
+debian/tmp/opt/rippled-reporting/etc/validators.txt opt/rippled-reporting/etc
+
+opt/rippled-reporting/bin/update-rippled-reporting.sh
+opt/rippled-reporting/bin/getRippledReportingInfo
+opt/rippled-reporting/etc/update-rippled-reporting-cron
+etc/logrotate.d/rippled-reporting

Builds/containers/packaging/dpkg/debian/rippled-reporting.links

@@ -0,0 +1,3 @@
+opt/rippled-reporting/etc/rippled-reporting.cfg etc/opt/rippled-reporting/rippled-reporting.cfg
+opt/rippled-reporting/etc/validators.txt etc/opt/rippled-reporting/validators.txt
+opt/rippled-reporting/bin/rippled-reporting usr/local/bin/rippled-reporting

Builds/containers/packaging/dpkg/debian/rippled-reporting.postinst

@@ -0,0 +1,33 @@
+#!/bin/sh
+set -e
+
+USER_NAME=rippled-reporting
+GROUP_NAME=rippled-reporting
+case "$1" in
+    configure)
+        id -u $USER_NAME >/dev/null 2>&1 || \
+        adduser --system --quiet \
+            --home /nonexistent --no-create-home \
+            --disabled-password \
+            --group "$GROUP_NAME"
+        chown -R $USER_NAME:$GROUP_NAME /var/log/rippled-reporting/
+        chown -R $USER_NAME:$GROUP_NAME /var/lib/rippled-reporting/
+        chmod 755 /var/log/rippled-reporting/
+        chmod 755 /var/lib/rippled-reporting/
+        chown -R $USER_NAME:$GROUP_NAME /opt/rippled-reporting
+
+    ;;
+
+    abort-upgrade|abort-remove|abort-deconfigure)
+    ;;
+
+    *)
+        echo "postinst called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+
+#DEBHELPER#
+
+exit 0

Builds/containers/packaging/dpkg/debian/rippled.conffiles

@@ -0,0 +1,2 @@
+/opt/ripple/etc/rippled.cfg
+/opt/ripple/etc/validators.txt

Builds/containers/packaging/dpkg/debian/rippled.install

@@ -0,0 +1,8 @@
+opt/ripple/bin/rippled
+opt/ripple/bin/validator-keys
+opt/ripple/bin/update-rippled.sh
+opt/ripple/bin/getRippledInfo
+opt/ripple/etc/rippled.cfg
+opt/ripple/etc/validators.txt
+opt/ripple/etc/update-rippled-cron
+etc/logrotate.d/rippled

Builds/containers/packaging/dpkg/debian/rippled.links

@@ -0,0 +1,3 @@
+opt/ripple/etc/rippled.cfg etc/opt/ripple/rippled.cfg
+opt/ripple/etc/validators.txt etc/opt/ripple/validators.txt
+opt/ripple/bin/rippled usr/local/bin/rippled

Builds/containers/packaging/dpkg/debian/rippled.postinst

@@ -0,0 +1,35 @@
+#!/bin/sh
+set -e
+
+USER_NAME=rippled
+GROUP_NAME=rippled
+case "$1" in
+    configure)
+        id -u $USER_NAME >/dev/null 2>&1 || \
+        adduser --system --quiet \
+            --home /nonexistent --no-create-home \
+            --disabled-password \
+            --group "$GROUP_NAME"
+        chown -R $USER_NAME:$GROUP_NAME /var/log/rippled/
+        chown -R $USER_NAME:$GROUP_NAME /var/lib/rippled/
+        chown -R $USER_NAME:$GROUP_NAME /opt/ripple
+        chmod 755 /var/log/rippled/
+        chmod 755 /var/lib/rippled/
+        chmod 644 /opt/ripple/etc/update-rippled-cron
+        chmod 644 /etc/logrotate.d/rippled
+        chown -R root:$GROUP_NAME /opt/ripple/etc/update-rippled-cron
+    ;;
+
+    abort-upgrade|abort-remove|abort-deconfigure)
+    ;;
+
+    *)
+        echo "postinst called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+
+#DEBHELPER#
+
+exit 0

Builds/containers/packaging/dpkg/debian/rippled.postrm

@@ -0,0 +1,17 @@
+#!/bin/sh
+set -e
+
+case "$1" in
+    purge|remove|upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
+    ;;
+
+    *)
+        echo "postrm called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+
+#DEBHELPER#
+
+exit 0