fix(doc-agent): shape review comments for GitHub createReviewComment API

Co-authored-by: Bart <11445373+bthomee@users.noreply.github.com>

.clang-format

@@ -0,0 +1,104 @@
+---
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterClass: true
+  AfterControlStatement: true
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: false
+  AfterObjCDeclaration: true
+  AfterStruct: true
+  AfterUnion: true
+  BeforeCatch: true
+  BeforeElse: true
+  IndentBraces: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+MaxEmptyLinesToKeep: 1
+---
+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
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: true
+ColumnLimit: 100
+CommentPragmas: "^ IWYU pragma:"
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+ForEachMacros: [Q_FOREACH, BOOST_FOREACH]
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex: "^<(test)/"
+    Priority: 1
+  - Regex: "^<(xrpld)/"
+    Priority: 2
+  - Regex: "^<(xrpl)/"
+    Priority: 3
+  - Regex: "^<(boost)/"
+    Priority: 4
+  - Regex: "^.*/"
+    Priority: 5
+  - Regex: '^.*\.h'
+    Priority: 6
+  - Regex: ".*"
+    Priority: 7
+IncludeIsMainRegex: "$"
+MainIncludeChar: AngleBracket
+IndentCaseLabels: true
+IndentFunctionDeclarationAfterType: false
+IndentRequiresClause: true
+IndentWidth: 4
+IndentWrappedFunctionNames: false
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+ReflowComments: true
+RequiresClausePosition: OwnLine
+SortIncludes: true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Cpp11
+TabWidth: 8
+UseTab: Never
+QualifierAlignment: Right
+---
+Language: Proto
+BasedOnStyle: Google
+ColumnLimit: 0
+IndentWidth: 2

.clang-tidy

@@ -0,0 +1,203 @@
+---
+Checks: "-*,
+  bugprone-argument-comment,
+  bugprone-assert-side-effect,
+  bugprone-bad-signal-to-kill-thread,
+  bugprone-bool-pointer-implicit-conversion,
+  bugprone-capturing-this-in-member-variable,
+  bugprone-casting-through-void,
+  bugprone-chained-comparison,
+  bugprone-compare-pointer-to-member-virtual-function,
+  bugprone-copy-constructor-init,
+  bugprone-crtp-constructor-accessibility,
+  bugprone-dangling-handle,
+  bugprone-dynamic-static-initializers,
+  bugprone-empty-catch,
+  bugprone-fold-init-type,
+  bugprone-forward-declaration-namespace,
+  bugprone-inaccurate-erase,
+  bugprone-inc-dec-in-conditions,
+  bugprone-incorrect-enable-if,
+  bugprone-incorrect-roundings,
+  bugprone-infinite-loop,
+  bugprone-integer-division,
+  bugprone-lambda-function-name,
+  bugprone-macro-parentheses,
+  bugprone-macro-repeated-side-effects,
+  bugprone-misleading-setter-of-reference,
+  bugprone-misplaced-operator-in-strlen-in-alloc,
+  bugprone-misplaced-pointer-arithmetic-in-alloc,
+  bugprone-misplaced-widening-cast,
+  bugprone-move-forwarding-reference,
+  bugprone-multi-level-implicit-pointer-conversion,
+  bugprone-multiple-new-in-one-expression,
+  bugprone-multiple-statement-macro,
+  bugprone-no-escape,
+  bugprone-non-zero-enum-to-bool-conversion,
+  bugprone-optional-value-conversion,
+  bugprone-parent-virtual-call,
+  bugprone-pointer-arithmetic-on-polymorphic-object,
+  bugprone-posix-return,
+  bugprone-redundant-branch-condition,
+  bugprone-reserved-identifier,
+  bugprone-return-const-ref-from-parameter,
+  bugprone-shared-ptr-array-mismatch,
+  bugprone-signal-handler,
+  bugprone-signed-char-misuse,
+  bugprone-sizeof-container,
+  bugprone-sizeof-expression,
+  bugprone-spuriously-wake-up-functions,
+  bugprone-standalone-empty,
+  bugprone-string-constructor,
+  bugprone-string-integer-assignment,
+  bugprone-string-literal-with-embedded-nul,
+  bugprone-stringview-nullptr,
+  bugprone-suspicious-enum-usage,
+  bugprone-suspicious-include,
+  bugprone-suspicious-memory-comparison,
+  bugprone-suspicious-memset-usage,
+  bugprone-suspicious-missing-comma,
+  bugprone-suspicious-realloc-usage,
+  bugprone-suspicious-semicolon,
+  bugprone-suspicious-string-compare,
+  bugprone-suspicious-stringview-data-usage,
+  bugprone-swapped-arguments,
+  bugprone-switch-missing-default-case,
+  bugprone-terminating-continue,
+  bugprone-throw-keyword-missing,
+  bugprone-too-small-loop-variable,
+  bugprone-unchecked-optional-access,
+  bugprone-undefined-memory-manipulation,
+  bugprone-undelegated-constructor,
+  bugprone-unhandled-exception-at-new,
+  bugprone-unhandled-self-assignment,
+  bugprone-unique-ptr-array-mismatch,
+  bugprone-unsafe-functions,
+  bugprone-unused-local-non-trivial-variable,
+  bugprone-unused-raii,
+  bugprone-unused-return-value,
+  bugprone-use-after-move,
+  bugprone-virtual-near-miss,
+  cppcoreguidelines-init-variables,
+  cppcoreguidelines-misleading-capture-default-by-value,
+  cppcoreguidelines-no-suspend-with-lock,
+  cppcoreguidelines-pro-type-member-init,
+  cppcoreguidelines-pro-type-static-cast-downcast,
+  cppcoreguidelines-rvalue-reference-param-not-moved,
+  cppcoreguidelines-use-default-member-init,
+  cppcoreguidelines-use-enum-class,
+  cppcoreguidelines-virtual-class-destructor,
+  hicpp-ignored-remove-result,
+  llvm-namespace-comment,
+  misc-const-correctness,
+  misc-definitions-in-headers,
+  misc-header-include-cycle,
+  misc-include-cleaner,
+  misc-misplaced-const,
+  misc-redundant-expression,
+  misc-static-assert,
+  misc-throw-by-value-catch-by-reference,
+  misc-unused-alias-decls,
+  misc-unused-using-decls,
+  modernize-concat-nested-namespaces,
+  modernize-deprecated-headers,
+  modernize-make-shared,
+  modernize-make-unique,
+  modernize-pass-by-value,
+  modernize-type-traits,
+  modernize-use-designated-initializers,
+  modernize-use-emplace,
+  modernize-use-equals-default,
+  modernize-use-equals-delete,
+  modernize-use-nodiscard,
+  modernize-use-override,
+  modernize-use-ranges,
+  modernize-use-scoped-lock,
+  modernize-use-starts-ends-with,
+  modernize-use-std-numbers,
+  modernize-use-using,
+  performance-faster-string-find,
+  performance-for-range-copy,
+  performance-implicit-conversion-in-loop,
+  performance-inefficient-vector-operation,
+  performance-move-const-arg,
+  performance-move-constructor-init,
+  performance-no-automatic-move,
+  performance-trivially-destructible,
+  readability-ambiguous-smartptr-reset-call,
+  readability-avoid-nested-conditional-operator,
+  readability-avoid-return-with-void-value,
+  readability-braces-around-statements,
+  readability-const-return-type,
+  readability-container-contains,
+  readability-container-size-empty,
+  readability-convert-member-functions-to-static,
+  readability-duplicate-include,
+  readability-else-after-return,
+  readability-enum-initial-value,
+  readability-identifier-naming,
+  readability-implicit-bool-conversion,
+  readability-make-member-function-const,
+  readability-math-missing-parentheses,
+  readability-misleading-indentation,
+  readability-non-const-parameter,
+  readability-redundant-casting,
+  readability-redundant-declaration,
+  readability-redundant-inline-specifier,
+  readability-redundant-member-init,
+  readability-redundant-string-init,
+  readability-reference-to-constructed-temporary,
+  readability-simplify-boolean-expr,
+  readability-static-definition-in-anonymous-namespace,
+  readability-suspicious-call-argument,
+  readability-use-std-min-max
+  "
+# ---
+# readability-inconsistent-declaration-parameter-name, # in this codebase this check will break a lot of arg names
+# readability-static-accessed-through-instance,        # this check is probably unnecessary. it makes the code less readable
+# ---
+
+CheckOptions:
+  bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
+  bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
+
+  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h"
+
+  readability-braces-around-statements.ShortStatementLines: 2
+  readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
+  readability-identifier-naming.ClassCase: CamelCase
+  readability-identifier-naming.StructCase: CamelCase
+  readability-identifier-naming.UnionCase: CamelCase
+  readability-identifier-naming.EnumCase: CamelCase
+  readability-identifier-naming.EnumConstantCase: CamelCase
+  readability-identifier-naming.ScopedEnumConstantCase: CamelCase
+  readability-identifier-naming.GlobalConstantCase: UPPER_CASE
+  readability-identifier-naming.GlobalConstantPrefix: "k"
+  readability-identifier-naming.GlobalVariableCase: CamelCase
+  readability-identifier-naming.GlobalVariablePrefix: "g"
+  readability-identifier-naming.ConstexprFunctionCase: camelBack
+  readability-identifier-naming.ConstexprMethodCase: camelBack
+  readability-identifier-naming.ClassMethodCase: camelBack
+  readability-identifier-naming.ClassMemberCase: camelBack
+  readability-identifier-naming.ClassConstantCase: UPPER_CASE
+  readability-identifier-naming.ClassConstantPrefix: "k"
+  readability-identifier-naming.StaticConstantCase: UPPER_CASE
+  readability-identifier-naming.StaticConstantPrefix: "k"
+  readability-identifier-naming.StaticVariableCase: UPPER_CASE
+  readability-identifier-naming.StaticVariablePrefix: "k"
+  readability-identifier-naming.ConstexprVariableCase: UPPER_CASE
+  readability-identifier-naming.ConstexprVariablePrefix: "k"
+  readability-identifier-naming.LocalConstantCase: camelBack
+  readability-identifier-naming.LocalVariableCase: camelBack
+  readability-identifier-naming.TemplateParameterCase: CamelCase
+  readability-identifier-naming.ParameterCase: camelBack
+  readability-identifier-naming.FunctionCase: camelBack
+  readability-identifier-naming.MemberCase: camelBack
+  readability-identifier-naming.PrivateMemberSuffix: _
+  readability-identifier-naming.ProtectedMemberSuffix: _
+  readability-identifier-naming.PublicMemberSuffix: ""
+  readability-identifier-naming.GlobalFunctionIgnoredRegexp: "^(to_string|hash_append|tuple_hash)$"
+
+HeaderFilterRegex: '^.*/(test|xrpl|xrpld)/.*\.(h|hpp|ipp)$'
+ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$'
+WarningsAsErrors: "*"

.codecov.yml

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

.gersemi/definitions.cmake

@@ -0,0 +1,101 @@
+# Custom CMake command definitions for gersemi formatting.
+# These stubs teach gersemi the signatures of project-specific commands
+# so it can format their invocations correctly.
+
+function(git_branch branch_val)
+endfunction()
+
+function(isolate_headers target A B scope)
+endfunction()
+
+function(create_symbolic_link target link)
+endfunction()
+
+function(xrpl_add_test name)
+endfunction()
+
+macro(exclude_from_default target_)
+endmacro()
+
+macro(exclude_if_included target_)
+endmacro()
+
+function(target_protobuf_sources target prefix)
+    set(options APPEND_PATH DESCRIPTORS)
+    set(oneValueArgs
+        LANGUAGE
+        OUT_VAR
+        EXPORT_MACRO
+        TARGET
+        PROTOC_OUT_DIR
+        PLUGIN
+        PLUGIN_OPTIONS
+        PROTOC_EXE
+    )
+    set(multiValueArgs
+        PROTOS
+        IMPORT_DIRS
+        GENERATE_EXTENSIONS
+        PROTOC_OPTIONS
+        DEPENDENCIES
+    )
+    cmake_parse_arguments(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()
+
+function(add_module parent name)
+endfunction()
+
+function(setup_protocol_autogen)
+endfunction()
+
+function(target_link_modules parent scope)
+endfunction()
+
+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(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()
+
+function(add_code_coverage_to_target name scope)
+endfunction()
+
+function(verbose_find_path variable name)
+    set(options
+        NO_CACHE
+        REQUIRED
+        OPTIONAL
+        NO_DEFAULT_PATH
+        NO_PACKAGE_ROOT_PATH
+        NO_CMAKE_PATH
+        NO_CMAKE_ENVIRONMENT_PATH
+        NO_SYSTEM_ENVIRONMENT_PATH
+        NO_CMAKE_SYSTEM_PATH
+        NO_CMAKE_INSTALL_PREFIX
+        CMAKE_FIND_ROOT_PATH_BOTH
+        ONLY_CMAKE_FIND_ROOT_PATH
+        NO_CMAKE_FIND_ROOT_PATH
+    )
+    set(oneValueArgs REGISTRY_VIEW VALIDATOR DOC)
+    set(multiValueArgs NAMES HINTS PATHS PATH_SUFFIXES)
+    cmake_parse_arguments(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()

.gersemirc

@@ -0,0 +1 @@
+definitions: [.gersemi]

.git-blame-ignore-revs

@@ -0,0 +1,81 @@
+# This feature requires Git >= 2.24
+# To use it by default in git blame:
+# git config blame.ignoreRevsFile .git-blame-ignore-revs
+
+# This file is sorted in reverse chronological order, with the most recent commits at the top.
+# The commits listed here are ignored by git blame, which is useful for formatting-only commits that would otherwise obscure the history of changes to a file.
+
+# refactor: Enable clang-tidy `readability-identifier-naming` check (#6571)
+8995564ed6b9e453e144bb663303072a3c1ba305
+# refactor: Enable remaining clang-tidy `cppcoreguidelines` checks (#6538)
+72f4cb097f626b08b02fc3efcb4aa11cb2e7adb8
+# refactor: Rename system name from 'ripple' to 'xrpld' (#6347)
+ffea3977f0b771fe8e43a8f74e4d393d63a7afd8
+# refactor: Update transaction folder structure (#6483)
+5865bd017f777491b4a956f9210be0c4161f5442
+# chore: Use gersemi instead of ancient cmake-format (#6486)
+0c74270b055133a57a497b5c9fc5a75f7647b1f4
+# chore: Apply clang-format width 100 (#6387)
+2c1fad102353e11293e3edde1c043224e7d3e983
+# chore: Set clang-format width to 100 in config file (#6387)
+25cca465538a56cce501477f9e5e2c1c7ea2d84c
+# chore: Set cmake-format width to 100 (#6386)
+469ce9f291a4480c38d4ee3baca5136b2f053cd0
+# refactor: Modularize app/tx (#6228)
+0976b2b68b64972af8e6e7c497900b5bce9fe22f
+# chore: Update clang-format to 21.1.8 (#6352)
+958d8f375453d80bb1aa4c293b5102c045a3e4b4
+# refactor: Replace include guards by '#pragma once' (#6322)
+34ef577604782ca8d6e1c17df8bd7470990a52ff
+# chore: Format all cmake files without comments (#6294)
+fe9c8d568fcf6ac21483024e01f58962dd5c8260
+# chore: Add cmake-format pre-commit hook (#6279)
+a0e09187b9370805d027c611a7e9ff5a0125282a
+# chore: Set ColumnLimit to 120 in clang-format (#6288)
+5f638f55536def0d88b970d1018a465a238e55f4
+# refactor: Fix typos in comments, configure cspell (#6164)
+3c9f5b62525cb1d6ca1153eeb10433db7d7379fd
+# refactor: Rename `rippled.cfg` to `xrpld.cfg` (#6098)
+3d1b3a49b3601a0a7037fa0b19d5df7b5e0e2fc1
+# refactor: Rename `ripple` namespace to `xrpl` (#5982)
+1eb0fdac6543706b4b9ddca57fd4102928a1f871
+# refactor: Rename `rippled` binary to `xrpld` (#5983)
+9eb84a561ef8bb066d89f098bd9b4ac71baed67c
+# refactor: Replaces secp256k1 source by Conan package (#6089)
+813bc4d9491b078bb950f8255f93b02f71320478
+# refactor: Remove unnecessary copyright notices already covered by LICENSE.md (#5929)
+1d42c4f6de6bf01d1286fc7459b17a37a5189e88
+# refactor: Rename `RIPPLE_` and `RIPPLED_` definitions to `XRPL_` (#5821)
+ada83564d894829424b0f4d922b0e737e07abbf7
+# refactor: Modularize shamap and nodestore (#5668)
+8eb233c2ea8ad5a159be73b77f0f5e1496d547ac
+# refactor: Modularise ledger (#5493)
+dc8b37a52448b005153c13a7f046ad494128cf94
+# chore: Update clang-format and prettier with pre-commit (#5709)
+c14ce956adeabe476ad73c18d73103f347c9c613
+# chore: Fix file formatting (#5718)
+896b8c3b54a22b0497cb0d1ce95e1095f9a227ce
+# chore: Reverts formatting changes to external files, adds formatting changes to proto files (#5711)
+b13370ac0d207217354f1fc1c29aef87769fb8a1
+# chore: Run prettier on all files (#5657)
+97f0747e103f13e26e45b731731059b32f7679ac
+# Reformat code with clang-format-18
+552377c76f55b403a1c876df873a23d780fcc81c
+# Recompute loops (#4997)
+d028005aa6319338b0adae1aebf8abe113162960
+# Rewrite includes (#4997)
+1d23148e6dd53957fcb6205c07a5c6cd7b64d50c
+# Rearrange sources (#4997)
+e416ee72ca26fa0c09d2aee1b68bdfb2b7046eed
+# Move CMake directory (#4997)
+2e902dee53aab2a8f27f32971047bb81e022f94f
+# Rewrite includes
+0eebe6a5f4246fced516d52b83ec4e7f47373edd
+# Format formerly .hpp files
+760f16f56835663d9286bd29294d074de26a7ba6
+# Rename .hpp to .h
+241b9ddde9e11beb7480600fd5ed90e1ef109b21
+# Consolidate external libraries
+e2384885f5f630c8f0ffe4bf21a169b433a16858
+# Format first-party source according to .clang-format
+50760c693510894ca368e90369b0cc2dabfd07f3

.gitattributes

@@ -1,9 +1,6 @@
 # Set default behaviour, in case users don't have core.autocrlf set.
 #* text=auto
-
-# These annoying files
-rippled.1 binary
-LICENSE binary
+# cspell: disable
 
 # Visual Studio
 *.sln       text eol=crlf

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,36 @@
+---
+name: Bug Report
+about: Create a report to help us improve xrpld
+title: "[Title with short description] (Version: [xrpld 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 './xrpld --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,25 @@
+---
+name: Feature Request
+about: Suggest a new feature for the xrpld project
+title: "[Title with short description] (Version: [xrpld 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-deps/action.yml

@@ -0,0 +1,48 @@
+name: Build Conan dependencies
+description: "Install Conan dependencies, optionally forcing a rebuild of all dependencies."
+
+# Note that actions do not support 'type' and all inputs are strings, see
+# https://docs.github.com/en/actions/reference/workflows-and-actions/metadata-syntax#inputs.
+inputs:
+  build_type:
+    description: 'The build type to use ("Debug", "Release").'
+    required: true
+  build_nproc:
+    description: "The number of processors to use for building."
+    required: true
+  force_build:
+    description: 'Force building of all dependencies ("true", "false").'
+    required: false
+    default: "false"
+  log_verbosity:
+    description: "The logging verbosity."
+    required: false
+    default: "verbose"
+  sanitizers:
+    description: "The sanitizers to enable."
+    required: false
+    default: ""
+
+runs:
+  using: composite
+  steps:
+    - name: Install Conan dependencies
+      shell: bash
+      env:
+        BUILD_NPROC: ${{ inputs.build_nproc }}
+        BUILD_OPTION: ${{ inputs.force_build == 'true' && '*' || 'missing' }}
+        BUILD_TYPE: ${{ inputs.build_type }}
+        LOG_VERBOSITY: ${{ inputs.log_verbosity }}
+        SANITIZERS: ${{ inputs.sanitizers }}
+      run: |
+        echo 'Installing dependencies.'
+        conan install \
+          --profile ci \
+          --build="${BUILD_OPTION}" \
+          --options:host='&:tests=True' \
+          --options:host='&:xrpld=True' \
+          --settings:all build_type="${BUILD_TYPE}" \
+          --conf:all tools.build:jobs=${BUILD_NPROC} \
+          --conf:all tools.build:verbosity="${LOG_VERBOSITY}" \
+          --conf:all tools.compilation:verbosity="${LOG_VERBOSITY}" \
+          .

.github/actions/generate-version/action.yml

@@ -0,0 +1,44 @@
+name: Generate build version number
+description: "Generate build version number."
+
+outputs:
+  version:
+    description: "The generated build version number."
+    value: ${{ steps.version.outputs.version }}
+
+runs:
+  using: composite
+  steps:
+    # When a tag is pushed, the version is used as-is.
+    - name: Generate version for tag event
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
+      shell: bash
+      env:
+        VERSION: ${{ github.ref_name }}
+      run: echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"
+
+    # When a tag is not pushed, then the version (e.g. 1.2.3-b0) is extracted
+    # from the BuildInfo.cpp file and the shortened commit hash appended to it.
+    # We use a plus sign instead of a hyphen because Conan recipe versions do
+    # not support two hyphens.
+    - name: Generate version for non-tag event
+      if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+      shell: bash
+      run: |
+        echo 'Extracting version from BuildInfo.cpp.'
+        VERSION="$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')"
+        if [[ -z "${VERSION}" ]]; then
+          echo 'Unable to extract version from BuildInfo.cpp.'
+          exit 1
+        fi
+
+        echo 'Appending shortened commit hash to version.'
+        SHA='${{ github.sha }}'
+        VERSION="${VERSION}+${SHA:0:7}"
+
+        echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"
+
+    - name: Output version
+      id: version
+      shell: bash
+      run: echo "version=${VERSION}" >> "${GITHUB_OUTPUT}"

.github/actions/setup-conan/action.yml

@@ -0,0 +1,46 @@
+name: Setup Conan
+description: "Set up Conan configuration, profile, and remote."
+
+inputs:
+  remote_name:
+    description: "The name of the Conan remote to use."
+    required: false
+    default: xrplf
+  remote_url:
+    description: "The URL of the Conan endpoint to use."
+    required: false
+    default: https://conan.ripplex.io
+
+runs:
+  using: composite
+
+  steps:
+    - name: Set up Conan configuration
+      shell: bash
+      run: |
+        echo 'Installing configuration.'
+        cat conan/global.conf ${{ runner.os == 'Linux' && '>>' || '>' }} $(conan config home)/global.conf
+
+        echo 'Conan configuration:'
+        conan config show '*'
+
+    - name: Set up Conan profile
+      shell: bash
+      run: |
+        echo 'Installing profile.'
+        conan config install conan/profiles/ -tf $(conan config home)/profiles/
+
+        echo 'Conan profile:'
+        conan profile show --profile ci
+
+    - name: Set up Conan remote
+      shell: bash
+      env:
+        REMOTE_NAME: ${{ inputs.remote_name }}
+        REMOTE_URL: ${{ inputs.remote_url }}
+      run: |
+        echo "Adding Conan remote '${REMOTE_NAME}' at '${REMOTE_URL}'."
+        conan remote add --index 0 --force "${REMOTE_NAME}" "${REMOTE_URL}"
+
+        echo 'Listing Conan remotes.'
+        conan remote list

.github/dependabot.yml

@@ -0,0 +1,45 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "ci: [DEPENDABOT] "
+    target-branch: develop
+
+  - package-ecosystem: github-actions
+    directory: .github/actions/build-deps/
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "ci: [DEPENDABOT] "
+    target-branch: develop
+
+  - package-ecosystem: github-actions
+    directory: .github/actions/generate-version/
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "ci: [DEPENDABOT] "
+    target-branch: develop
+
+  - package-ecosystem: github-actions
+    directory: .github/actions/setup-conan/
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "ci: [DEPENDABOT] "
+    target-branch: develop

.github/doc-coverage-thresholds.json

@@ -0,0 +1,22 @@
+{
+  "global_minimum": 0,
+  "ratchet_mode": "no_decrease",
+  "new_file_minimum": 80,
+  "module_thresholds": {
+    "include/xrpl/basics/": 0,
+    "include/xrpl/crypto/": 0,
+    "include/xrpl/protocol/": 0,
+    "include/xrpl/ledger/": 0,
+    "include/xrpl/tx/": 0,
+    "include/xrpl/server/": 0,
+    "include/xrpl/nodestore/": 0,
+    "include/xrpl/shamap/": 0,
+    "include/xrpl/resource/": 0,
+    "xrpld/rpc/": 0,
+    "xrpld/overlay/": 0,
+    "xrpld/peerfinder/": 0,
+    "xrpld/consensus/": 0,
+    "xrpld/app/": 0,
+    "libxrpl/": 0
+  }
+}

.github/pull_request_template.md

@@ -0,0 +1,69 @@
+<!--
+This PR template helps you to write a good pull request description.
+Please feel free to include additional useful information even beyond what is requested below.
+
+If your branch is on a personal fork and has a name that allows it to
+run CI build/test jobs (e.g. "ci/foo"), remember to rename it BEFORE
+opening the PR.  This avoids unnecessary redundant test runs. Renaming
+the branch after opening the PR will close the PR.
+https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-branches-in-your-repository/renaming-a-branch
+-->
+
+## High Level Overview of Change
+
+<!--
+Please include a summary of the changes.
+This may be a direct input to the release notes.
+If too broad, please consider splitting into multiple PRs.
+If a relevant task or issue, please link it here.
+-->
+
+### Context of Change
+
+<!--
+Please include the context of a change.
+If a bug fix, when was the bug introduced? What was the behavior?
+If a new feature, why was this architecture chosen? What were the alternatives?
+If a refactor, how is this better than the previous implementation?
+
+If there is a spec or design document for this feature, please link it here.
+-->
+
+### 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/scripts/check-pr-description.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+
+"""
+Checks that a pull request description has been customized from the
+pull_request_template.md. Exits with code 1 if the description is empty
+or identical to the template (ignoring HTML comments and whitespace).
+
+Usage:
+    python check-pr-description.py --template-file TEMPLATE --pr-body-file BODY
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+
+def normalize(text: str) -> str:
+    """Strip HTML comments, trim lines, and remove blank lines."""
+    # Remove HTML comments (possibly multi-line)
+    text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
+    # Strip each line and drop empties
+    lines = [line.strip() for line in text.splitlines()]
+    lines = [line for line in lines if line]
+    return "\n".join(lines)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Check that a PR description differs from the template."
+    )
+    parser.add_argument(
+        "--template-file",
+        type=Path,
+        required=True,
+        help="Path to the pull request template file.",
+    )
+    parser.add_argument(
+        "--pr-body-file",
+        type=Path,
+        required=True,
+        help="Path to a file containing the PR body text.",
+    )
+    args = parser.parse_args()
+
+    template_path: Path = args.template_file
+    pr_body_path: Path = args.pr_body_file
+
+    if not template_path.is_file():
+        print(f"::error::Template file {template_path} not found")
+        return 1
+
+    if not pr_body_path.is_file():
+        print(f"::error::PR body file {pr_body_path} not found")
+        return 1
+
+    template = template_path.read_text(encoding="utf-8")
+    pr_body = pr_body_path.read_text(encoding="utf-8")
+
+    # Check if the PR body is empty or whitespace-only
+    if not pr_body.strip():
+        print(
+            "::error::PR description is empty. "
+            "Please fill in the pull request template."
+        )
+        return 1
+
+    norm_template = normalize(template)
+    norm_pr_body = normalize(pr_body)
+
+    if norm_pr_body == norm_template:
+        print(
+            "::error::PR description (ignoring HTML comments) is identical"
+            " to the template. Please fill in the details of your change."
+            f"\n\nVisible template content:\n---\n{norm_template}\n---"
+            f"\n\nVisible PR description content:\n---\n{norm_pr_body}\n---"
+        )
+        return 1
+
+    print("PR description has been customized from the template.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/scripts/doc-agent/.env.example

@@ -0,0 +1,18 @@
+# Copy this file to .env and fill in your values.
+# .env is gitignored and will never be committed.
+
+# Required: Anthropic API key for the Claude Agent SDK.
+ANTHROPIC_API_KEY=sk-ant-...
+
+# Optional: Override the path to the xrpld repo root.
+# Defaults to three levels up from this directory (the repo this lives in).
+# XRPLD_ROOT=/path/to/xrpld
+
+# Optional: Override the model used by the agent.
+# Defaults to claude-opus-4-7.
+# DOC_AGENT_MODEL=claude-opus-4-7
+
+# Max output tokens per model turn (passed through to Claude Code).
+# Default in Claude Code is 8192. Bump for skill regeneration so large
+# modules don't truncate.
+CLAUDE_CODE_MAX_OUTPUT_TOKENS=32000

.github/scripts/doc-agent/.gitignore

@@ -0,0 +1,7 @@
+node_modules/
+dist/
+*.log
+.env
+.env.local
+doc-review-report.md
+doc-review-comments.json

.github/scripts/doc-agent/README.md

@@ -0,0 +1,122 @@
+# doc-agent
+
+Automated documentation agent for the xrpld C++ codebase. Built on the
+Claude Agent SDK.
+
+## What it does
+
+Three modes:
+
+- **document** — Add Doxygen `/** */` documentation to a C++ file or
+  directory. For each target file, the agent reads the sibling
+  `<file>.ai.md` (high-signal prose generated by the athenah-ai pipeline),
+  the module skill, and the file itself, then writes Doxygen comments per
+  the standards in `docs/DOCUMENTATION_STANDARDS.md`.
+- **review** — Given a git diff range, detect documentation drift. Used by
+  the `doc-review` GitHub Action and locally for testing.
+- **regen-skills** — Rebuild a module's skill file at
+  `docs/skills/soul/<module>.md` from the `.ai.md` files in that module
+  and the existing skill content.
+
+## Requirements
+
+- Node.js >= 20.12 (for native `--env-file` support)
+- `ANTHROPIC_API_KEY` (in `.env` or exported in shell)
+- Tools the agent uses: `git`, `gh` (for `--pr`)
+
+## Install
+
+```sh
+cd .github/scripts/doc-agent
+npm install
+cp .env.example .env
+# edit .env and set ANTHROPIC_API_KEY
+```
+
+The npm scripts auto-load `.env` via Node's `--env-file-if-exists` flag.
+You can also export the variables in your shell — both work.
+
+## Build and lint
+
+```sh
+npm run typecheck     # type check without emitting
+npm run build         # compile to dist/
+npm run lint          # biome lint
+npm run format        # biome format --write
+npm run check         # lint + format check (read-only)
+npm run check:fix     # lint + format + fix
+```
+
+## Usage
+
+```sh
+# Document a single file (reads sibling .ai.md if present)
+npm run document include/xrpl/basics/base_uint.h
+
+# Document an entire module
+npm run document include/xrpl/basics/
+
+# Review a git range
+npm run review develop..HEAD
+
+# Review a PR
+npm run review -- --pr 1234
+
+# Regenerate a skill file from this module's .ai.md inputs
+npm run regen-skills protocol
+npm run regen-skills ledger
+```
+
+When invoked outside the xrpld repo, set `XRPLD_ROOT` in `.env` to the path
+of the checkout you want to operate on.
+
+## ai.md context files
+
+The doc-agent reads a sibling `<file>.ai.md` next to each source file when
+documenting it. These are produced by the upstream `athenah-ai` pipeline
+and treated as the authoritative source of intent. They are gitignored
+(`*.ai.md` in `.gitignore`) and should be removed once the initial
+documentation pass is complete.
+
+## Outputs
+
+The `review` mode writes two files in the current directory:
+
+- `doc-review-report.md` — markdown summary, posted as the PR comment
+- `doc-review-comments.json` — array of inline review comments, posted
+  individually on the PR diff
+
+## Layout
+
+```
+doc-agent/
+├── package.json
+├── tsconfig.json
+├── biome.json
+├── prompts/
+│   ├── document-file.md     # System prompt for documentation mode
+│   ├── review-diff.md       # System prompt for review mode
+│   └── regen-skill.md       # System prompt for regen-skills mode
+└── src/
+    ├── index.ts             # CLI entry point
+    ├── config.ts            # Paths, model, module-skill map
+    ├── prompt-loader.ts     # Loads prompts + module skill context
+    ├── document.ts          # Document mode
+    ├── review.ts            # Review mode
+    ├── regen-skills.ts      # Regen-skills mode
+    └── types.ts             # Shared types
+```
+
+## Module skills
+
+The agent injects per-module context from `docs/skills/soul/*.md` into its
+system prompt based on the file path being processed. The mapping lives in
+`src/config.ts` (`MODULE_SKILL_MAP`).
+
+## Notes
+
+- Prompts live in markdown files, not source, so they can be edited without
+  touching code.
+- The `document` mode uses `permissionMode: 'acceptEdits'` so the agent
+  writes directly to the target files. Run against a clean git tree so you
+  can review and revert if needed.

.github/scripts/doc-agent/biome.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "ignore": ["dist", "node_modules"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100,
+    "lineEnding": "lf"
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "trailingCommas": "all",
+      "semicolons": "always",
+      "arrowParentheses": "always"
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "correctness": {
+        "noUnusedVariables": "error",
+        "noUnusedImports": "error",
+        "useExhaustiveDependencies": "error"
+      },
+      "style": {
+        "useConst": "error",
+        "useTemplate": "error",
+        "useImportType": "error",
+        "useExportType": "error",
+        "noNonNullAssertion": "warn"
+      },
+      "suspicious": {
+        "noExplicitAny": "error",
+        "noConsoleLog": "off"
+      },
+      "complexity": {
+        "noUselessTypeConstraint": "error",
+        "useArrowFunction": "error",
+        "useLiteralKeys": "off"
+      }
+    }
+  },
+  "organizeImports": {
+    "enabled": true
+  }
+}

.github/scripts/doc-agent/install-skills.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+SRC_DIR="$REPO_ROOT/docs/skills"
+DEST_DIR="$REPO_ROOT/.claude/skills"
+
+if [ ! -d "$SRC_DIR" ]; then
+  echo "Source directory not found: $SRC_DIR" >&2
+  exit 1
+fi
+
+mkdir -p "$DEST_DIR"
+
+shopt -s nullglob
+moved=0
+for src in "$SRC_DIR"/*.md; do
+  name="$(basename "$src" .md)"
+  [ "$name" = "index" ] && continue
+
+  skill_dir="$DEST_DIR/$name"
+  mkdir -p "$skill_dir"
+  cp "$src" "$skill_dir/SKILL.md"
+  echo "Installed: $name -> $skill_dir/SKILL.md"
+  moved=$((moved + 1))
+done
+
+echo "Done. Installed $moved skill(s) to $DEST_DIR"

.github/scripts/doc-agent/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xrpld-doc-agent",
+  "version": "0.1.0",
+  "description": "Automated documentation agent for the xrpld C++ codebase. Uses the Claude Agent SDK to generate Doxygen documentation and detect doc drift on PRs.",
+  "type": "module",
+  "private": true,
+  "bin": {
+    "doc-agent": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node --env-file-if-exists=.env dist/index.js",
+    "dev": "tsx --env-file-if-exists=.env src/index.ts",
+    "document": "tsx --env-file-if-exists=.env src/index.ts document",
+    "review": "tsx --env-file-if-exists=.env src/index.ts review",
+    "audit": "tsx --env-file-if-exists=.env src/index.ts audit",
+    "regen-skills": "tsx --env-file-if-exists=.env src/index.ts regen-skills",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome lint src",
+    "format": "biome format --write src",
+    "check": "biome check src",
+    "check:fix": "biome check --write src"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.1.10"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=20.12"
+  }
+}

.github/scripts/doc-agent/prompts/audit-file.md

@@ -0,0 +1,105 @@
+You are auditing a C++ source file in the xrpld (XRP Ledger daemon)
+codebase to determine how completely the file's existing Doxygen
+documentation reflects the authoritative design intent captured in its
+sibling `.ai.md` file.
+
+This is a read-only audit. Do NOT modify the file.
+
+## Input
+
+You receive up to four pieces of context:
+- A **primary** C++ file (.h, .hpp, or .cpp) — the file this audit is
+  scoped to.
+- The **primary's `.ai.md`** — authoritative prose about the primary file's
+  purpose, design, invariants, failure modes, and non-obvious behavior.
+- A **partner** file — the header/source counterpart of the primary
+  (e.g., the `.h` partner of a `.cpp` primary), if one exists.
+- The **partner's `.ai.md`** — authoritative prose about the partner
+  file, if one exists.
+
+The **primary's `.ai.md`** is the source of truth for what concepts must
+be documented for the primary file. The partner's `.ai.md` is context:
+it tells you which concepts the project considers a *partner-file*
+responsibility (e.g., a "this class is the public contract for X" theme
+that naturally lives in the header). Use it to avoid flagging concepts
+that the project's own intent assigns to the partner.
+
+Documentation that satisfies a primary-file concept may live in **either**
+the primary file or the partner file — both count as "reflected." Header
+docs (the contract) and source docs (the implementation) together form
+the full documentation surface, so a concept covered on the header is
+not "missed" on the source even if the primary is the source.
+
+## Task
+
+For every distinct concept, invariant, design decision, state transition,
+ordering constraint, or failure mode in the `.ai.md`, decide:
+
+1. **Where it belongs.** Each concept has a *correct home* in the
+   documentation:
+   - `"header"` — the public *contract*: what the function/class promises
+     to its caller. Examples: parameter meanings, return-value semantics,
+     thread-safety guarantees, when an exception is thrown, "this class
+     represents X". These belong on the declaration in the header.
+   - `"source"` — the *implementation*: algorithm, ordering of checks,
+     state transitions, internal invariants, failure modes, the **why**
+     behind non-obvious choices. These belong on the definition in the
+     `.cpp` file.
+   - `"either"` — concepts that are equally at home in either place
+     (e.g., a file-level `@file` block describing overall role).
+2. **Whether it is reflected** in the correct home. A concept is
+   reflected if a reader of that file's docstrings can understand the
+   same point without reading the `.ai.md`. Verbatim wording is not
+   required; equivalent meaning is enough. A concept whose correct home
+   is the source but only appears on the header is **not** correctly
+   placed — it should also (or instead) be on the `.cpp` definition.
+
+A concept is **missed** if it is silent, paraphrased so thinly the
+reader cannot rely on the docstring, or documented only in the wrong
+home (e.g., implementation depth on the header instead of the source).
+
+Do **not** flag implementation details the `.ai.md` does not call out as
+design-significant. Do **not** invent concepts not in the `.ai.md`.
+
+## Output
+
+Respond with **only** a JSON object — no prose, no markdown fences:
+
+```
+{
+  "file": "<path relative to repo root>",
+  "ai_md_concepts": <integer count of distinct concepts identified in the .ai.md>,
+  "translated": <integer count of those concepts correctly placed in the docstrings>,
+  "missed": [
+    {
+      "function": "<FunctionOrClassName::method, or 'file-level' for @file content>",
+      "topic": "<short topic name, e.g. 'Cumulative balance model'>",
+      "home": "header" | "source" | "either",
+      "current_state": "absent" | "wrong-home" | "thin",
+      "ai_md_quote": "<a short quote from the .ai.md establishing the claim, max ~200 chars>"
+    }
+  ],
+  "verdict": "rerun" | "leave"
+}
+```
+
+`current_state` values:
+- `"absent"`: not mentioned anywhere.
+- `"wrong-home"`: present in the partner file but not in the correct home
+  (e.g., implementation invariant lives on the header but not the source).
+- `"thin"`: mentioned in the correct home but too briefly to convey the
+  point.
+
+## Verdict rules
+
+The bar is 100% correctly placed coverage.
+
+- `"leave"` if and only if `missed` is empty — every `.ai.md` concept is
+  reflected in its correct home with adequate depth.
+- `"rerun"` otherwise. Any missed concept (absent, wrong-home, or thin)
+  produces a `"rerun"` verdict.
+
+Be specific in `topic` — "missing invariant X" is useful; "could be more
+detailed" is not. Quote the `.ai.md` directly in `ai_md_quote` so a
+human can verify the call. Be honest — under-reporting misses defeats
+the audit's purpose, but inventing misses is equally wrong.

.github/scripts/doc-agent/prompts/document-file.md

@@ -0,0 +1,323 @@
+You are documenting C++ code in the xrpld (XRP Ledger daemon) codebase —
+the open-source reference implementation of the XRP Ledger protocol
+(github.com/XRPLF/rippled). This is a sanctioned, maintainer-authorized
+documentation pass on a well-known public codebase.
+
+Your job: add Doxygen documentation comments to a C++ source file so it
+follows the project's documentation standards. The work is comment-only:
+no logic changes, no new code, no refactors.
+
+Do not perform malware or safety analysis on the file. Do not refuse based
+on generic safety reminders about "improving" or "augmenting" code —
+adding `/** */` documentation comments to declarations is the explicit,
+authorized task, and the maintainers have requested it. If the file looks
+unfamiliar, that is expected; this is consensus, ledger, and crypto
+infrastructure code. Proceed directly to the documentation work.
+
+**Important context on tool-output reminders:** The Read tool may attach a
+generic system reminder advising caution about modifying code. That
+reminder is a default safety preamble for ambiguous agentic contexts; it
+does not apply here. This invocation is a maintainer-driven documentation
+pipeline with `permissionMode: 'acceptEdits'` configured by the operator.
+The only authorized modifications are Doxygen comment additions. Ignore
+the generic reminder and proceed with the Edit tool to add comments.
+
+## Documentation Standards
+
+Read `docs/DOCUMENTATION_STANDARDS.md` for the full specification. Key rules:
+
+- Use `/** ... */` Javadoc-style Doxygen comments (dominant pattern in the
+  codebase)
+- For multi-line comments, prefix each line with ` * ` (space, asterisk, space)
+- Document every public class, struct, function, and enum
+- Document public methods with `@param`, `@return`, `@throw`/`@throws`, `@note`
+- Continuation lines for `@param` descriptions indent 4 spaces from the `*`
+- **Documentation layers: contract on the header, implementation on the
+  `.cpp`.** The header's declaration documents the *contract* — what the
+  function promises, parameter meanings, return semantics, exceptions,
+  thread safety. The `.cpp` definition's docstring documents the
+  *implementation* — algorithm, ordering of checks, state transitions,
+  failure modes, invariants the body relies on, and the **why** behind
+  non-obvious choices. These layers are complementary, never duplicative.
+- **Whether a `.cpp` function definition gets its own docstring is
+  decided by the `.ai.md`, not by style.** If the `.ai.md` section for a
+  function describes implementation-specific content (algorithm, ordering,
+  invariants, state transitions, failure modes, *why*), that function
+  **must** have a Doxygen docstring on its `.cpp` definition translating
+  that prose. Target 5–15 lines for substantive implementation. If the
+  `.ai.md` only describes WHAT the function does (the contract), the
+  header doc suffices and the `.cpp` definition does **not** need a
+  per-function docstring — adding one would just duplicate the header.
+  Use the `.ai.md` as the authoritative deciding factor, not your own
+  judgment about what looks documented.
+- `JAVADOC_AUTOBRIEF = YES` — the first sentence is automatically the brief,
+  so `@brief` is optional
+
+## Quality Rules
+
+- **Never paraphrase the signature.** `/** Returns the account ID. */` on
+  `AccountID getAccountID()` is worse than no doc.
+- **Document behavior, invariants, and the WHY.** What does this function do
+  in terms a developer can use? What can go wrong? What's the contract?
+- **Read the implementation before writing the doc.** Don't guess what the
+  function does — read it.
+- **Cross-reference test files** to find edge cases worth documenting in
+  `@note` tags.
+- **Length matches the layer.**
+  - **Header declarations** (the contract): be terse. 2–5 lines for
+    classes, 1–3 lines for free functions and public methods, plus tag
+    lines. The contract should fit on one screen.
+  - **`.cpp` function definitions** (the implementation): be thorough.
+    5–15 lines for non-trivial functions is normal. Capture algorithm,
+    ordering of checks, state transitions, failure modes, and the **why**.
+    The `.ai.md` Authoritative AI Context is your source — translate its
+    prose into Doxygen on the actual definitions; do not summarize it
+    away. A function whose `.ai.md` section is three paragraphs should not
+    end up with a two-line docstring.
+- **When you are not sure what the code does, the `.ai.md` is
+  authoritative.** Use what it says about that function rather than
+  skipping the docstring. Skipping is not a safe default — it leaves the
+  reader worse off than translating the `.ai.md`'s explanation onto the
+  declaration. Inventing facts not in the code, the `.ai.md`, the module
+  skill, or the tests *is* worse than no docs, but that is the only case
+  where "no doc" is the right answer for a non-trivial public entity.
+
+## Module Context
+
+Before you start, read the relevant skill file in `docs/skills/` for
+the module you're working on. These capture per-module conventions, key
+classes, and gotchas:
+
+- `basics`, `crypto`, `json`, `beast` — foundation utilities
+- `protocol` — STObject, SField, Serializer, TER codes, Features, Keylets
+- `ledger` — ReadView/ApplyView, state tables, payment sandbox
+- `tx` / `transactors` — transaction pipeline
+- `consensus`, `peering`, `nodestore`, `shamap`, `rpc` — see `docs/skills/`
+
+## Process
+
+Documenting a declaration is not the same as "writing a doxygen comment
+above it". It is producing the **total** set of comments that should
+surround the declaration after this pass — which includes the docstring
+and any inline comments that remain inside the function body or next to
+a data-literal initializer. Existing comments in the file are inputs,
+not outputs you are preserving.
+
+For each entity (class, struct, public method, free function in a header,
+enum, public field):
+
+1. **Read** the declaration, its full implementation, and **every comment
+   that is currently attached to it** — the Doxygen above it, any `//!`
+   line, any inline `// ...` annotations next to its initializer or
+   inside its body. Treat all of these as raw information about intent.
+2. **Cross-reference** the ai.md context (already injected in your
+   prompt) and the module skill file. Also grep for the entity's name
+   to find callers and tests where the behavioral contract is exercised
+   — those are often the best source of what to write.
+3. **Decide what the reader needs**, in this order:
+   a. A docstring that captures behavior, contract, invariants, and the
+      WHY. This is the primary deliverable.
+   b. Inline comments **only** where they document something the
+      docstring cannot reasonably hold — typically a non-obvious local
+      invariant, a workaround for a specific bug, a tricky branch whose
+      WHY is genuinely local. If the inline comment just narrates what
+      the next line does, it does not belong.
+4. **Produce a single edit** that replaces the entity's full comment
+   surface with the result of step 3. Concretely:
+   - If you wrote a docstring whose contents subsume an existing `//!`
+     or section-header prose comment, **remove** the old comment as part
+     of the same edit. Do not leave both.
+   - If you wrote a docstring whose `@note` or body covers the meaning
+     of an inline annotation on a map row, array literal, or magic
+     constant inside the entity, **remove** that inline annotation.
+     Leaving it duplicates what the docstring says.
+   - If you wrote a docstring on a function whose body has line-by-line
+     narration of control flow (`// check this`, `// now do that`),
+     **remove** the narration unless a specific line documents a real,
+     non-obvious WHY.
+   - Section banner comments (`// --- Avalanche tuning ---`) may stay as
+     short visual dividers if they help scanning a long struct, but any
+     multi-line prose in them that is now in the per-field Doxygen
+     should be cut.
+5. **Do not delete** comments that capture a WHY the docstring does not
+   cover: a workaround for a real bug, a non-obvious invariant local to
+   one branch, a reference to a ticket or RFC. If a pre-existing
+   comment contains information you did not put in the new docstring,
+   either fold it into the docstring or leave it in place.
+
+## Worked examples
+
+These show the exact transformations expected. The "AFTER" column is the
+state the file must be in when you finish. If your edit leaves the file
+in the "BEFORE" state, the pass has failed.
+
+### Example 1: section-header prose → short banner
+
+BEFORE:
+```cpp
+//-------------------------------------------------------------------------
+// Validation and proposal durations are relative to NetClock times, so use
+// second resolution
+
+/** Maximum age of a validation relative to its ledger's close time.
+ *  ... (rest of docstring already explains NetClock semantics) ...
+ */
+std::chrono::seconds const validationVALID_WALL = std::chrono::minutes{5};
+```
+
+AFTER:
+```cpp
+// --- NetClock-domain parameters ---
+
+/** Maximum age of a validation relative to its ledger's close time.
+ *  ... (rest of docstring already explains NetClock semantics) ...
+ */
+std::chrono::seconds const validationVALID_WALL = std::chrono::minutes{5};
+```
+
+The multi-line prose was redundant with the new per-field Doxygen and the
+file-level `@file` block. Replace with a single-line banner.
+
+### Example 2: inline annotations on a data literal → removed
+
+BEFORE:
+```cpp
+/** Avalanche state machine cutoffs.
+ *
+ *  | State  | Time | Yes-vote | Next   |
+ *  |--------|------|----------|--------|
+ *  | Init   | 0    | 50       | Mid    |
+ *  | Mid    | 50   | 65       | Late   |
+ *  ...
+ */
+std::map<AvalancheState, AvalancheCutoff> const avalancheCutoffs{
+    // {state, {time, percent, nextState}},
+    // Initial state: 50% of nodes must vote yes
+    {AvalancheState::Init,  {.consensusTime = 0,   .consensusPct = 50, .next = AvalancheState::Mid}},
+    // mid-consensus starts after 50% of the previous round time, and
+    // requires 65% yes
+    {AvalancheState::Mid,   {.consensusTime = 50,  .consensusPct = 65, .next = AvalancheState::Late}},
+    // ...
+};
+```
+
+AFTER:
+```cpp
+/** Avalanche state machine cutoffs.
+ *
+ *  | State  | Time | Yes-vote | Next   |
+ *  |--------|------|----------|--------|
+ *  | Init   | 0    | 50       | Mid    |
+ *  | Mid    | 50   | 65       | Late   |
+ *  ...
+ */
+std::map<AvalancheState, AvalancheCutoff> const avalancheCutoffs{
+    {AvalancheState::Init,  {.consensusTime = 0,   .consensusPct = 50, .next = AvalancheState::Mid}},
+    {AvalancheState::Mid,   {.consensusTime = 50,  .consensusPct = 65, .next = AvalancheState::Late}},
+    // ...
+};
+```
+
+The per-row inline comments restate the table that is now in the
+docstring above. They go. The schema comment `// {state, {time, percent, ...}}`
+also goes — the designated-initializer field names make the schema obvious.
+
+### Example 3: body narration in a documented function → removed
+
+BEFORE:
+```cpp
+/** Query the avalanche state machine.
+ *  ...
+ *  @note `at()` calls on `avalancheCutoffs` are safe because the map is
+ *      constructed with all four valid keys.
+ */
+inline std::pair<...> getNeededWeight(...)
+{
+    // at() can throw, but the map is built by hand to ensure all valid
+    // values are available.
+    auto const& currentCutoff = p.avalancheCutoffs.at(currentState);
+    // Should we consider moving to the next state?
+    if (currentCutoff.next != currentState && currentRounds >= minimumRounds)
+    {
+        // at() can throw, but the map is built by hand to ensure all
+        // valid values are available.
+        auto const& nextCutoff = p.avalancheCutoffs.at(currentCutoff.next);
+        // See if enough time has passed to move on to the next.
+        XRPL_ASSERT(...);
+        if (percentTime >= nextCutoff.consensusTime)
+        {
+            return {nextCutoff.consensusPct, currentCutoff.next};
+        }
+    }
+    return {currentCutoff.consensusPct, {}};
+}
+```
+
+AFTER:
+```cpp
+/** Query the avalanche state machine.
+ *  ...
+ *  @note `at()` calls on `avalancheCutoffs` are safe because the map is
+ *      constructed with all four valid keys.
+ */
+inline std::pair<...> getNeededWeight(...)
+{
+    auto const& currentCutoff = p.avalancheCutoffs.at(currentState);
+    if (currentCutoff.next != currentState && currentRounds >= minimumRounds)
+    {
+        auto const& nextCutoff = p.avalancheCutoffs.at(currentCutoff.next);
+        XRPL_ASSERT(...);
+        if (percentTime >= nextCutoff.consensusTime)
+        {
+            return {nextCutoff.consensusPct, currentCutoff.next};
+        }
+    }
+    return {currentCutoff.consensusPct, {}};
+}
+```
+
+Every removed comment was either restating what the next line does
+(`// Should we consider moving to the next state?` on an `if`) or
+duplicating the docstring's `@note` (`// at() can throw...`). None of
+them documented a non-obvious WHY local to that line.
+
+### Calibration: when an inline comment STAYS
+
+If the body contains a comment that documents a real local WHY —
+something the function-level docstring cannot reasonably hold — keep it.
+
+```cpp
+// Workaround for boost #12345: pass nullptr instead of the empty buffer.
+boost::asio::buffer(nullptr, 0);
+
+// We deliberately do not lock here: the caller is required to hold
+// lock_ across this method and the recursion would deadlock.
+internalUpdate();
+```
+
+These are non-removable. They are not restating the code; they are
+explaining something the reader cannot derive from the line.
+
+## Rules that apply throughout
+
+- Do NOT modify code logic — only adjust comments and Doxygen.
+- Do NOT document entities that don't need it (private members with
+  obvious purpose, trivial defaulted constructors, getters whose name is
+  self-explanatory).
+- Do NOT read the primary's `.ai.md` file yourself — it is already in
+  your prompt as "Primary's Authoritative AI Context."
+- The partner's `.ai.md` (if any) is also already in your prompt as
+  "Partner's Authoritative AI Context." Use it to understand what
+  concepts the project assigns to the partner file, so you don't
+  duplicate them on the primary.
+- The "Primary's Authoritative AI Context" is the source of truth for
+  this file's intent. Your task is to translate that prose into Doxygen
+  on the actual declarations in the primary file, in the layer
+  (header vs. source) where each concept correctly belongs.
+- **Only modify the primary file.** Use Read (not Edit) on the partner
+  file — it is reference context, not an editing target.
+
+When you finish, summarize:
+- How many entities you documented
+- Any entities you skipped and why
+- Any code patterns you discovered that should be added to a skill file

.github/scripts/doc-agent/prompts/regen-skill.md

@@ -0,0 +1,67 @@
+You are updating a per-module skill file for the xrpld codebase.
+
+A "skill" is a single markdown file at `docs/skills/<module>.md` that
+captures the institutional knowledge for one module: what it does, key
+classes, conventions, gotchas, and how to work in it. The skill file is
+loaded as context whenever an agent works on code in that module.
+
+## Inputs
+
+You will be given:
+- The current skill file for the module (the baseline to update)
+- A list of `.ai.md` files describing the source files in this module
+  (one per source file, with high-signal prose about purpose and design)
+
+## Your task
+
+Produce a new, improved skill file that integrates the knowledge from the
+ai.md files into the existing skill. Specifically:
+
+1. Update the description of the module's responsibility if the ai.md files
+   reveal more accurate or detailed framing
+2. Add any classes, patterns, or invariants the skill is missing
+3. Update lists of key files / entry points / conventions
+4. Add gotchas and non-obvious behavior surfaced by the ai.md files
+5. Keep the structure of the existing skill (don't reorganize for the sake
+   of it — only restructure if the existing structure is genuinely failing)
+6. Be terse. A skill file is a reference card, not a textbook. 200-500 lines
+   is typical; over 1000 means you're padding.
+
+## Quality rules
+
+- **Do not duplicate the ai.md content.** Aggregate, synthesize, distill.
+  The skill is the module-level view; individual file details belong in
+  ai.md (and eventually in inline Doxygen comments).
+- **Preserve accurate existing content.** Don't rewrite working sections.
+- **Cite file paths** for specific claims (e.g., "see `STAmount.h:roundToScale`").
+- **Flag contradictions.** If two ai.md files describe the same concept
+  differently, surface the conflict rather than silently picking one.
+- **Keep prose grounded.** No marketing language. No "robust, scalable,
+  enterprise-grade" filler. Engineers reading this need facts.
+
+## Output — Chunked Writing (REQUIRED)
+
+You have a per-turn output cap (32K tokens). For larger modules, a
+complete skill file will not fit in a single tool call. You MUST write
+the file in chunks across multiple tool calls. Do not try to emit the
+whole file in one Write — it will be truncated mid-content.
+
+Process:
+1. **First chunk (Write)**: Call the `Write` tool with the start of the
+   skill: the title heading, the opening overview, and the first 1–2
+   major sections. Keep this chunk under ~20K characters of content.
+2. **Subsequent chunks (Edit)**: For each remaining section, call the
+   `Edit` tool with:
+   - `old_string` = the last line currently at the end of the file (must
+     be unique enough to match unambiguously — use the full last line)
+   - `new_string` = that same last line **plus the next 1–2 sections**
+   appended
+   Keep each chunk under ~20K characters.
+3. **Repeat** until the skill is complete. There is no maximum number
+   of Edit calls.
+
+After the file is fully written, respond with a one-line confirmation
+listing how many chunks you wrote.
+
+DO NOT emit the skill content in your text response. The file is the
+output; the text response is only for confirmation.

.github/scripts/doc-agent/prompts/review-diff.md

@@ -0,0 +1,55 @@
+You are reviewing a pull request to the xrpld (XRP Ledger daemon) codebase
+for documentation drift.
+
+Your job: given a git diff, determine whether the changes invalidate
+existing Doxygen documentation comments, or introduce new public API
+surface that lacks documentation.
+
+## Rules
+
+- Only flag REAL semantic drift: changed behavior, new parameters, removed
+  functionality, changed return values, new error conditions, changed
+  invariants.
+- Do NOT flag cosmetic changes (whitespace, formatting, internal renames
+  that don't change semantics).
+- Do NOT suggest docs for private implementation details unless the logic
+  is genuinely non-obvious.
+- Do NOT paraphrase function signatures. Good docs explain WHY and what
+  BEHAVIOR — not what the code literally does.
+- Be terse: 1-3 sentences per finding.
+
+## Process
+
+1. For each changed file, get the git diff and the current file content
+2. Read existing doc comments on the modified entities
+3. For each modified entity, ask:
+   - Did behavior change in a way the docs miss?
+   - Did parameters or return values change?
+   - Are there new error conditions?
+   - Did the contract / invariant change?
+   - Is this a NEW public API surface with no docs?
+4. Read the module's skill file in `docs/skills/soul/` for context
+5. Read related tests if it helps you understand the change
+6. Output findings as structured JSON (see below)
+
+## Output Format
+
+```json
+{
+  "summary": "One-paragraph summary of doc state for this PR",
+  "issues": [
+    {
+      "file": "include/xrpl/protocol/Payment.h",
+      "line": 42,
+      "severity": "warning" | "suggestion",
+      "message": "Brief description of the doc issue",
+      "suggested_doc": "Optional: suggested doc comment text"
+    }
+  ]
+}
+```
+
+- `severity: warning` = doc is now incorrect / misleading
+- `severity: suggestion` = new code lacks docs, would be nice to add
+
+If no issues found, return `{"summary": "Documentation is up to date.", "issues": []}`.

.github/scripts/doc-agent/src/audit.ts

@@ -0,0 +1,295 @@
+/**
+ * Audit mode: measure how completely each file's Doxygen documentation
+ * reflects the authoritative design intent in its sibling .ai.md.
+ *
+ * For each C++ file under the target that has a .ai.md sibling:
+ *   - Locate its header/source partner (if any) and the partner's .ai.md.
+ *   - Send primary + partner files and both .ai.md files to the agent.
+ *   - Parse a structured JSON verdict per file.
+ *
+ * Writes:
+ *   - doc-audit-report.json  Aggregated per-file results.
+ *   - doc-audit-report.md    Human-readable summary.
+ */
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { MODEL, XRPLD_ROOT } from './config.js';
+import { findPartner } from './pairing.js';
+import { loadSystemPrompt } from './prompt-loader.js';
+
+const SOURCE_EXTS: ReadonlySet<string> = new Set(['.h', '.hpp', '.cpp']);
+const MAX_FILE_CHARS = 24_000;
+const MAX_AI_MD_CHARS = 16_000;
+const DEFAULT_CONCURRENCY = 5;
+
+interface AuditMissed {
+  function: string;
+  topic: string;
+  home: 'header' | 'source' | 'either';
+  current_state: 'absent' | 'wrong-home' | 'thin';
+  ai_md_quote: string;
+}
+
+interface AuditResult {
+  file: string;
+  ai_md_concepts: number;
+  translated: number;
+  missed: AuditMissed[];
+  verdict: 'rerun' | 'leave';
+}
+
+/**
+ * Recursively find C++ source files under a target path that have a
+ * sibling .ai.md.
+ */
+function findAuditTargets(target: string): string[] {
+  const absTarget = resolve(XRPLD_ROOT, target);
+  if (!existsSync(absTarget)) {
+    throw new Error(`Target does not exist: ${absTarget}`);
+  }
+
+  const out: string[] = [];
+  const consider = (file: string): void => {
+    const dotIdx = file.lastIndexOf('.');
+    if (dotIdx === -1) return;
+    const ext = file.slice(dotIdx);
+    if (!SOURCE_EXTS.has(ext)) return;
+    if (!existsSync(`${file}.ai.md`)) return;
+    out.push(file);
+  };
+
+  const stat = statSync(absTarget);
+  if (stat.isFile()) {
+    consider(absTarget);
+    return out;
+  }
+
+  const walk = (dir: string): void => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile()) consider(full);
+    }
+  };
+  walk(absTarget);
+  return out;
+}
+
+/** Read a file, capping at maxChars to keep prompts within budget. */
+async function readCapped(absPath: string, maxChars: number): Promise<string> {
+  const text = await readFile(absPath, 'utf8');
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n\n... [truncated, ${text.length - maxChars} bytes elided] ...`;
+}
+
+/** Extract a JSON object from a possibly-fenced model response. */
+function extractJson(response: string): AuditResult | null {
+  const fenced = response.match(/```json\s*([\s\S]*?)```/);
+  const raw = fenced?.[1] ?? response.match(/(\{[\s\S]*\})/)?.[1];
+  if (raw === undefined) return null;
+  try {
+    return JSON.parse(raw) as AuditResult;
+  } catch {
+    return null;
+  }
+}
+
+/** Audit a single primary file against its .ai.md and partner context. */
+async function auditFile(absPrimary: string): Promise<AuditResult | null> {
+  const relPrimary = relative(XRPLD_ROOT, absPrimary);
+  console.log(`\n=== Auditing: ${relPrimary} ===`);
+
+  const primary = await readCapped(absPrimary, MAX_FILE_CHARS);
+  const primaryAiMd = await readCapped(`${absPrimary}.ai.md`, MAX_AI_MD_CHARS);
+
+  const absPartner = findPartner(absPrimary);
+  const relPartner = absPartner === null ? null : relative(XRPLD_ROOT, absPartner);
+  const partner = absPartner === null ? null : await readCapped(absPartner, MAX_FILE_CHARS);
+  const partnerAiMdPath = absPartner === null ? null : `${absPartner}.ai.md`;
+  const partnerAiMd =
+    partnerAiMdPath !== null && existsSync(partnerAiMdPath)
+      ? await readCapped(partnerAiMdPath, MAX_AI_MD_CHARS)
+      : null;
+
+  const partnerBlock =
+    relPartner === null || partner === null
+      ? ''
+      : `
+
+## Partner File (${relPartner})
+\`\`\`
+${partner}
+\`\`\`${
+          partnerAiMd === null
+            ? ''
+            : `
+
+## Partner's .ai.md (${relPartner}.ai.md)
+${partnerAiMd}`
+        }`;
+
+  const userPrompt = `Audit the documentation coverage of this file against its authoritative .ai.md.
+
+## Primary File (${relPrimary})
+\`\`\`
+${primary}
+\`\`\`
+
+## Primary's .ai.md (${relPrimary}.ai.md)
+${primaryAiMd}${partnerBlock}
+
+Output JSON per the schema in the system prompt. The "file" field MUST be
+"${relPrimary}".`;
+
+  const systemPrompt = await loadSystemPrompt('audit-file', relPrimary);
+
+  let response = '';
+  const result = query({
+    prompt: userPrompt,
+    options: {
+      model: MODEL,
+      systemPrompt,
+      cwd: XRPLD_ROOT,
+      allowedTools: ['Read', 'Glob', 'Grep'],
+      permissionMode: 'acceptEdits',
+    },
+  });
+
+  for await (const message of result) {
+    if (message.type === 'assistant') {
+      const content = message.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'text') response += block.text;
+        }
+      }
+    }
+    if (message.type === 'result') {
+      const cost = message.total_cost_usd?.toFixed(4) ?? '?';
+      const inTok = message.usage?.['input_tokens'] ?? 0;
+      const outTok = message.usage?.['output_tokens'] ?? 0;
+      console.log(`  [Cost: $${cost}, Tokens: ${inTok}/${outTok}]`);
+    }
+  }
+
+  const parsed = extractJson(response);
+  if (parsed === null) {
+    console.warn(`  No JSON output for ${relPrimary}, skipping`);
+    return null;
+  }
+  parsed.file = relPrimary;
+  return parsed;
+}
+
+/** Render the aggregated markdown report. */
+function buildReport(results: readonly AuditResult[]): string {
+  const total = results.length;
+  const reruns = results.filter((r) => r.verdict === 'rerun');
+  const totalConcepts = results.reduce((s, r) => s + r.ai_md_concepts, 0);
+  const totalTranslated = results.reduce((s, r) => s + r.translated, 0);
+  const overallRate = totalConcepts === 0 ? 0 : Math.round((totalTranslated / totalConcepts) * 100);
+
+  const lines: string[] = [
+    '# Documentation Audit Report',
+    '',
+    `**Files audited:** ${total}`,
+    `**Overall translation rate:** ${overallRate}% (${totalTranslated} of ${totalConcepts} .ai.md concepts reflected in docstrings)`,
+    `**Files flagged for re-run:** ${reruns.length}`,
+    '',
+    '## Files flagged for re-run',
+    '',
+  ];
+
+  if (reruns.length === 0) {
+    lines.push('_None — all audited files passed._', '');
+  } else {
+    lines.push('| File | Translated | Missed | Rate |', '|------|-----------:|-------:|-----:|');
+    for (const r of reruns.sort(
+      (a, b) =>
+        a.translated / Math.max(a.ai_md_concepts, 1) - b.translated / Math.max(b.ai_md_concepts, 1),
+    )) {
+      const rate = r.ai_md_concepts === 0 ? 0 : Math.round((r.translated / r.ai_md_concepts) * 100);
+      lines.push(`| \`${r.file}\` | ${r.translated} | ${r.missed.length} | ${rate}% |`);
+    }
+    lines.push('', '## Top missed concepts (sampled)', '');
+    for (const r of reruns.slice(0, 10)) {
+      if (r.missed.length === 0) continue;
+      lines.push(`### \`${r.file}\``, '');
+      for (const m of r.missed.slice(0, 5)) {
+        lines.push(`- **${m.function}** — ${m.topic}`);
+        lines.push(`  > ${m.ai_md_quote.replace(/\n/g, ' ').slice(0, 200)}`);
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Run async work over a list of items with bounded concurrency. Mirrors the
+ * minimal slice of p-limit we actually need; collects results in input order.
+ */
+async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  limit: number,
+  worker: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  const results = new Array<R>(items.length);
+  let next = 0;
+
+  async function pump(): Promise<void> {
+    while (true) {
+      const index = next++;
+      if (index >= items.length) return;
+      // biome-ignore lint/style/noNonNullAssertion: index < items.length
+      results[index] = await worker(items[index]!, index);
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(limit, items.length) }, pump);
+  await Promise.all(workers);
+  return results;
+}
+
+/**
+ * Audit every C++ file with a .ai.md sibling under the target path.
+ *
+ * Concurrency is read from the AUDIT_CONCURRENCY env var (default 5).
+ */
+export async function auditTarget(target: string): Promise<void> {
+  const files = findAuditTargets(target);
+  const concurrency = Number(process.env['AUDIT_CONCURRENCY']) || DEFAULT_CONCURRENCY;
+  console.log(
+    `Found ${files.length} file(s) with .ai.md siblings to audit (concurrency=${concurrency}).`,
+  );
+
+  let completed = 0;
+  const raw = await mapWithConcurrency(files, concurrency, async (file) => {
+    try {
+      const result = await auditFile(file);
+      completed++;
+      console.log(`  Progress: ${completed}/${files.length}`);
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`  Audit failed for ${file}: ${message}`);
+      completed++;
+      console.log(`  Progress: ${completed}/${files.length}`);
+      return null;
+    }
+  });
+  const results = raw.filter((r): r is AuditResult => r !== null);
+
+  const report = buildReport(results);
+  await writeFile('doc-audit-report.md', report);
+  await writeFile('doc-audit-report.json', JSON.stringify(results, null, 2));
+
+  const reruns = results.filter((r) => r.verdict === 'rerun').length;
+  console.log(`\nAudited: ${results.length}/${files.length}`);
+  console.log(`Flagged for re-run: ${reruns}`);
+  console.log('Reports: doc-audit-report.md, doc-audit-report.json');
+}

.github/scripts/doc-agent/src/config.ts

@@ -0,0 +1,77 @@
+/**
+ * Shared configuration for doc-agent.
+ *
+ * Paths are resolved relative to the doc-agent directory so the tool works
+ * regardless of where it's invoked from.
+ */
+
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/** Absolute path to the doc-agent root (parent of src/). */
+export const AGENT_DIR: string = resolve(__dirname, '..');
+
+/** Absolute path to the prompts directory. */
+export const PROMPTS_DIR: string = resolve(AGENT_DIR, 'prompts');
+
+/**
+ * Absolute path to the xrpld repo root.
+ *
+ * Defaults to three levels up from doc-agent (which lives at
+ * .github/scripts/doc-agent/). Override with the XRPLD_ROOT env var when
+ * running against a different checkout.
+ */
+export const XRPLD_ROOT: string = process.env['XRPLD_ROOT'] ?? resolve(AGENT_DIR, '..', '..', '..');
+
+/** Model used for documentation generation and review. */
+export const MODEL: string = process.env['DOC_AGENT_MODEL'] ?? 'claude-sonnet-4-6';
+
+/** Absolute path to the skills directory inside the xrpld repo. */
+export const SKILLS_DIR: string = resolve(XRPLD_ROOT, 'docs', 'skills');
+
+/**
+ * Map module path prefixes to their skill file name in docs/skills/soul/.
+ *
+ * Used to inject module-specific context into the agent's system prompt
+ * when documenting or reviewing code in that module.
+ */
+export const MODULE_SKILL_MAP: Readonly<Record<string, string | null>> = {
+  'src/libxrpl/basics/': null,
+  'src/libxrpl/crypto/': 'cryptography.md',
+  'src/libxrpl/json/': null,
+  'src/libxrpl/beast/': null,
+  'src/libxrpl/protocol/': 'protocol.md',
+  'src/libxrpl/ledger/': 'ledger.md',
+  'src/libxrpl/tx/': 'transactors.md',
+  'src/libxrpl/nodestore/': 'nodestore.md',
+  'src/libxrpl/shamap/': 'shamap.md',
+  'src/libxrpl/rdb/': 'sql.md',
+  'src/xrpld/consensus/': 'consensus.md',
+  'src/xrpld/overlay/': 'peering.md',
+  'src/xrpld/peerfinder/': 'peering.md',
+  'src/xrpld/rpc/': 'rpc.md',
+  'include/xrpl/crypto/': 'cryptography.md',
+  'include/xrpl/protocol/': 'protocol.md',
+  'include/xrpl/ledger/': 'ledger.md',
+  'include/xrpl/tx/': 'transactors.md',
+  'include/xrpl/nodestore/': 'nodestore.md',
+  'include/xrpl/shamap/': 'shamap.md',
+};
+
+/**
+ * Resolve which skill file applies to a given source path.
+ *
+ * @param sourcePath - Path relative to the xrpld repo root
+ * @returns The skill file name, or null if no skill applies
+ */
+export function skillForPath(sourcePath: string): string | null {
+  for (const [prefix, skillFile] of Object.entries(MODULE_SKILL_MAP)) {
+    if (sourcePath.startsWith(prefix) || sourcePath.includes(`/${prefix}`)) {
+      return skillFile;
+    }
+  }
+  return null;
+}

.github/scripts/doc-agent/src/document.ts

@@ -0,0 +1,160 @@
+/**
+ * Document mode: add Doxygen docs to a file or all files in a directory.
+ */
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { MODEL, XRPLD_ROOT } from './config.js';
+import { findPartner } from './pairing.js';
+import { loadSystemPrompt } from './prompt-loader.js';
+
+const CPP_EXTENSIONS: ReadonlySet<string> = new Set(['.h', '.hpp', '.cpp']);
+
+/**
+ * Recursively find all C++ source files under a target path.
+ *
+ * @param target - File or directory path (relative to xrpld root or absolute)
+ * @returns Absolute paths of all matching files
+ */
+function findCppFiles(target: string): string[] {
+  const absTarget = resolve(XRPLD_ROOT, target);
+  if (!existsSync(absTarget)) {
+    throw new Error(`Target does not exist: ${absTarget}`);
+  }
+
+  const stat = statSync(absTarget);
+  if (stat.isFile()) {
+    return [absTarget];
+  }
+
+  const results: string[] = [];
+  const walk = (dir: string): void => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        const dotIdx = entry.name.lastIndexOf('.');
+        if (dotIdx === -1) continue;
+        const ext = entry.name.slice(dotIdx);
+        if (CPP_EXTENSIONS.has(ext)) {
+          results.push(full);
+        }
+      }
+    }
+  };
+  walk(absTarget);
+  return results;
+}
+
+/**
+ * Read the sibling .ai.md file for a source file, if one exists.
+ *
+ * The athenah-ai pipeline produces a `<file>.ai.md` companion for every
+ * documented source file (e.g., `Slice.h` -> `Slice.h.ai.md`). When present,
+ * it is high-signal prose describing the file's purpose, design, and
+ * non-obvious behavior — the agent should use it as the authoritative
+ * source of intent.
+ */
+async function readAiContext(absPath: string): Promise<string | null> {
+  const aiPath = `${absPath}.ai.md`;
+  if (!existsSync(aiPath)) return null;
+  return await readFile(aiPath, 'utf8');
+}
+
+/**
+ * Document a single file by running the documentation agent against it.
+ *
+ * Inject the partner file's path + its `.ai.md` (if any) into the prompt
+ * so the agent can apply the "contract on header, implementation on
+ * source" policy with full visibility into the other half. The agent
+ * Reads the partner only as reference; only the primary file is edited.
+ */
+async function documentFile(absPath: string): Promise<void> {
+  const relPath = relative(XRPLD_ROOT, absPath);
+  console.log(`\n=== Documenting: ${relPath} ===`);
+
+  const systemPrompt = await loadSystemPrompt('document-file', relPath);
+  const aiContext = await readAiContext(absPath);
+  const aiContextBlock =
+    aiContext === null
+      ? ''
+      : `\n\n## Primary's Authoritative AI Context (${relPath}.ai.md)\n\nThe following is high-signal prose describing this file's purpose, design,\nand non-obvious behavior. Treat it as the source of truth for intent and\nbehavior. Your job is to translate this into structured Doxygen \`/** */\`\ncomments on the actual declarations.\n\n---\n\n${aiContext}\n---`;
+
+  const absPartner = findPartner(absPath);
+  const relPartner = absPartner === null ? null : relative(XRPLD_ROOT, absPartner);
+  const partnerAiContext = absPartner === null ? null : await readAiContext(absPartner);
+  const partnerBlock =
+    relPartner === null
+      ? ''
+      : `\n\n## Partner File\n\nThis file's partner is **${relPartner}**. Use the Read tool to see its\ncurrent docstrings before deciding what belongs on the primary. A concept\nalready documented on the partner does not need to be duplicated here.\nConversely, an implementation-depth concept currently on the partner that\nbelongs on the source (or vice versa) should be moved.${
+          partnerAiContext === null
+            ? ''
+            : `\n\n### Partner's Authoritative AI Context (${relPartner}.ai.md)\n\n---\n\n${partnerAiContext}\n---`
+        }`;
+
+  const userPrompt = `Add Doxygen documentation to: ${relPath}
+
+The file is rooted at ${XRPLD_ROOT}. Use the Read tool to read it, the Edit
+tool to add documentation, and Glob/Grep to find related tests or callers
+when needed.${
+    relPartner === null
+      ? ''
+      : ` Use Read on the partner file (${relPartner}) to see what's already
+documented there.`
+  }
+
+Do not modify any code logic — only add documentation comments to the
+primary file (${relPath}). Do NOT edit the partner file.${aiContextBlock}${partnerBlock}`;
+
+  const result = query({
+    prompt: userPrompt,
+    options: {
+      model: MODEL,
+      systemPrompt,
+      cwd: XRPLD_ROOT,
+      allowedTools: ['Read', 'Edit', 'Glob', 'Grep', 'Bash'],
+      permissionMode: 'acceptEdits',
+    },
+  });
+
+  for await (const message of result) {
+    if (message.type === 'assistant') {
+      const content = message.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'text') {
+            process.stdout.write(block.text);
+          }
+        }
+      }
+    }
+    if (message.type === 'result') {
+      const cost = message.total_cost_usd?.toFixed(4) ?? '?';
+      const inTok = message.usage?.['input_tokens'] ?? 0;
+      const outTok = message.usage?.['output_tokens'] ?? 0;
+      console.log(`\n[Cost: $${cost}, Tokens: ${inTok}/${outTok}]`);
+    }
+  }
+}
+
+/**
+ * Document a file or every C++ file under a directory.
+ *
+ * @param target - File or directory path
+ */
+export async function documentTarget(target: string): Promise<void> {
+  const files = findCppFiles(target);
+  console.log(`Found ${files.length} C++ file(s) to document.`);
+
+  for (const file of files) {
+    try {
+      await documentFile(file);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to document ${file}: ${message}`);
+    }
+  }
+}

.github/scripts/doc-agent/src/index.ts

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * xrpld doc-agent CLI entry point.
+ *
+ * @example
+ *   doc-agent document src/libxrpl/basics/base_uint.h
+ *   doc-agent document include/xrpl/basics/
+ *   doc-agent review develop..HEAD
+ *   doc-agent review --pr 1234
+ *   doc-agent regen-skills protocol
+ */
+
+import { auditTarget } from './audit.js';
+import { documentTarget } from './document.js';
+import { regenSkills } from './regen-skills.js';
+import { reviewDiff } from './review.js';
+
+const USAGE = `
+xrpld doc-agent
+
+Usage:
+  doc-agent document <file-or-directory>   Add Doxygen documentation
+  doc-agent review <base>..<head>          Detect doc drift in range
+  doc-agent review --pr <number>           Detect doc drift for a PR
+  doc-agent audit <file-or-directory>      Measure how completely each file's
+                                           docstrings reflect its .ai.md intent;
+                                           outputs doc-audit-report.{md,json}
+  doc-agent regen-skills <module>          Regenerate docs/skills/soul/<module>.md
+                                           from sibling .ai.md files
+
+Environment:
+  ANTHROPIC_API_KEY  (required)  Anthropic API key
+  XRPLD_ROOT         (optional)  Path to xrpld repo root (default: repo root)
+  DOC_AGENT_MODEL    (optional)  Model override (default: claude-opus-4-7)
+`;
+
+function printUsageAndExit(code: number): never {
+  console.error(USAGE);
+  process.exit(code);
+}
+
+const HELP_MODES: ReadonlySet<string> = new Set(['help', '--help', '-h']);
+
+async function main(): Promise<void> {
+  const [mode, ...args] = process.argv.slice(2);
+
+  if (process.env['ANTHROPIC_API_KEY'] === undefined) {
+    console.error('ERROR: ANTHROPIC_API_KEY environment variable is required.');
+    process.exit(1);
+  }
+
+  if (mode === undefined || HELP_MODES.has(mode)) {
+    printUsageAndExit(0);
+  }
+
+  if (mode === 'document') {
+    const target = args[0];
+    if (target === undefined) printUsageAndExit(1);
+    await documentTarget(target);
+    return;
+  }
+
+  if (mode === 'review') {
+    if (args.length === 0) printUsageAndExit(1);
+    await reviewDiff(args);
+    return;
+  }
+
+  if (mode === 'audit') {
+    const target = args[0];
+    if (target === undefined) printUsageAndExit(1);
+    await auditTarget(target);
+    return;
+  }
+
+  if (mode === 'regen-skills') {
+    const moduleName = args[0];
+    if (moduleName === undefined) printUsageAndExit(1);
+    await regenSkills(moduleName);
+    return;
+  }
+
+  console.error(`Unknown mode: ${mode}`);
+  printUsageAndExit(1);
+}
+
+main().catch((err: unknown) => {
+  const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+  console.error('FATAL:', message);
+  process.exit(1);
+});

.github/scripts/doc-agent/src/pairing.ts

@@ -0,0 +1,47 @@
+/**
+ * Header/source pairing for C++ files in the xrpld layout.
+ *
+ * libxrpl: src/libxrpl/<X>.cpp <-> include/xrpl/<X>.h
+ * xrpld:   src/xrpld/<X>.cpp   <-> src/xrpld/<X>.h (same directory)
+ *
+ * Inline-only headers may have no .cpp partner; standalone .cpp may have
+ * no .h partner.
+ */
+
+import { existsSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { XRPLD_ROOT } from './config.js';
+
+/**
+ * Compute the partner file path for a given primary, by swapping the
+ * extension between header/source. Returns null if no candidate exists
+ * on disk.
+ */
+export function findPartner(absPrimary: string): string | null {
+  const rel = relative(XRPLD_ROOT, absPrimary);
+  const dotIdx = rel.lastIndexOf('.');
+  if (dotIdx === -1) return null;
+  const stem = rel.slice(0, dotIdx);
+  const ext = rel.slice(dotIdx);
+
+  const candidates: string[] = [];
+
+  if (ext === '.cpp') {
+    if (stem.startsWith('src/libxrpl/')) {
+      const tail = stem.slice('src/libxrpl/'.length);
+      candidates.push(`include/xrpl/${tail}.h`, `include/xrpl/${tail}.hpp`);
+    }
+    candidates.push(`${stem}.h`, `${stem}.hpp`);
+  } else if (ext === '.h' || ext === '.hpp') {
+    if (stem.startsWith('include/xrpl/')) {
+      candidates.push(`src/libxrpl/${stem.slice('include/xrpl/'.length)}.cpp`);
+    }
+    candidates.push(`${stem}.cpp`);
+  }
+
+  for (const candidate of candidates) {
+    const abs = resolve(XRPLD_ROOT, candidate);
+    if (existsSync(abs) && abs !== absPrimary) return abs;
+  }
+  return null;
+}

.github/scripts/doc-agent/src/prompt-loader.ts

@@ -0,0 +1,34 @@
+/**
+ * Loads system prompts and injects module-specific skill context.
+ */
+
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { PROMPTS_DIR, SKILLS_DIR, skillForPath } from './config.js';
+
+/**
+ * Load a system prompt from prompts/ and append the relevant module skill
+ * if one applies to the given source path.
+ *
+ * @param promptName - Base name of the prompt file (without .md extension)
+ * @param sourcePath - Path relative to the xrpld repo root
+ * @returns The fully-assembled system prompt
+ */
+export async function loadSystemPrompt(promptName: string, sourcePath: string): Promise<string> {
+  const basePromptPath = resolve(PROMPTS_DIR, `${promptName}.md`);
+  const basePrompt = await readFile(basePromptPath, 'utf8');
+
+  const skillFile = skillForPath(sourcePath);
+  if (skillFile === null) {
+    return basePrompt;
+  }
+
+  const skillPath = resolve(SKILLS_DIR, skillFile);
+  if (!existsSync(skillPath)) {
+    return basePrompt;
+  }
+
+  const skill = await readFile(skillPath, 'utf8');
+  return `${basePrompt}\n\n## Module Skill (${skillFile})\n\n${skill}`;
+}

.github/scripts/doc-agent/src/regen-skills.ts

@@ -0,0 +1,166 @@
+/**
+ * Regen-skills mode: rebuild a module's skill file from ai.md inputs.
+ *
+ * For a given module (e.g. `protocol`, `ledger`, `consensus`), collect all
+ * `.ai.md` files under the matching source paths and ask the Agent SDK to
+ * write an updated `docs/skills/<module>.md`.
+ *
+ * The agent writes the file via the `Write` tool rather than returning the
+ * skill content as text. This avoids hitting the per-turn output token
+ * limit on large modules (which previously truncated several skill files).
+ */
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { MODEL, MODULE_SKILL_MAP, PROMPTS_DIR, SKILLS_DIR, XRPLD_ROOT } from './config.js';
+
+interface AiFile {
+  readonly sourcePath: string;
+  readonly content: string;
+}
+
+/** Resolve which source-tree prefixes feed a given skill file. */
+function prefixesForSkill(skillFile: string): string[] {
+  return Object.entries(MODULE_SKILL_MAP)
+    .filter(([, mapped]) => mapped === skillFile)
+    .map(([prefix]) => prefix);
+}
+
+/** Walk a directory and collect all sibling .ai.md files. */
+function collectAiFiles(prefix: string): string[] {
+  const absDir = resolve(XRPLD_ROOT, prefix);
+  if (!existsSync(absDir) || !statSync(absDir).isDirectory()) return [];
+
+  const results: string[] = [];
+  const walk = (dir: string): void => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && entry.name.endsWith('.ai.md')) {
+        results.push(full);
+      }
+    }
+  };
+  walk(absDir);
+  return results;
+}
+
+async function loadAiFiles(absPaths: readonly string[]): Promise<AiFile[]> {
+  const files: AiFile[] = [];
+  for (const absPath of absPaths) {
+    const content = await readFile(absPath, 'utf8');
+    files.push({
+      sourcePath: relative(XRPLD_ROOT, absPath).replace(/\.ai\.md$/, ''),
+      content,
+    });
+  }
+  return files;
+}
+
+/**
+ * Regenerate the skill file for a given module name.
+ *
+ * @param moduleName - The skill file name without extension (e.g. "protocol",
+ *   "ledger"). Must match a value in MODULE_SKILL_MAP.
+ */
+export async function regenSkills(moduleName: string): Promise<void> {
+  const skillFile = `${moduleName}.md`;
+  const prefixes = prefixesForSkill(skillFile);
+
+  if (prefixes.length === 0) {
+    const known = Array.from(
+      new Set(Object.values(MODULE_SKILL_MAP).filter((v): v is string => v !== null)),
+    );
+    throw new Error(`Unknown module: ${moduleName}. Valid modules: ${known.join(', ')}`);
+  }
+
+  console.log(`Regenerating skill: ${skillFile}`);
+  console.log(`  Source prefixes: ${prefixes.join(', ')}`);
+
+  const aiPaths = prefixes.flatMap((prefix) => collectAiFiles(prefix));
+  if (aiPaths.length === 0) {
+    console.warn('  No .ai.md files found for this module. Skipping.');
+    return;
+  }
+  console.log(`  Found ${aiPaths.length} .ai.md file(s)`);
+
+  const aiFiles = await loadAiFiles(aiPaths);
+  const skillPath = resolve(SKILLS_DIR, skillFile);
+  const skillRelPath = relative(XRPLD_ROOT, skillPath);
+  const existingSkill = existsSync(skillPath)
+    ? await readFile(skillPath, 'utf8')
+    : '(no existing skill file — create a new one)';
+
+  const systemPrompt = await readFile(resolve(PROMPTS_DIR, 'regen-skill.md'), 'utf8');
+
+  const aiBlocks = aiFiles
+    .map((f) => `\n### \`${f.sourcePath}\`\n\n${f.content}`)
+    .join('\n\n---\n');
+
+  const userPrompt = `Regenerate the skill file at: \`${skillRelPath}\`
+
+Use the **Write** tool to write the new content to that path. Do NOT return
+the skill content in your message — write it directly to the file. This
+avoids hitting per-turn output token limits.
+
+## Existing skill content
+
+${existingSkill}
+
+## AI context files for this module
+
+${aiBlocks}
+
+When you have written the file, respond with a brief one-line confirmation.`;
+
+  const result = query({
+    prompt: userPrompt,
+    options: {
+      model: MODEL,
+      systemPrompt,
+      cwd: XRPLD_ROOT,
+      allowedTools: ['Write', 'Edit', 'Read', 'Glob', 'Grep'],
+      permissionMode: 'acceptEdits',
+    },
+  });
+
+  let writeCount = 0;
+  let editCount = 0;
+  for await (const message of result) {
+    if (message.type === 'assistant') {
+      const content = message.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'tool_use' && block.name === 'Write') {
+            writeCount++;
+            const input = block.input as { file_path?: string } | undefined;
+            if (input?.file_path !== undefined) {
+              console.log(`    Write: ${input.file_path}`);
+            }
+          }
+          if (block.type === 'tool_use' && block.name === 'Edit') {
+            editCount++;
+            const input = block.input as { file_path?: string } | undefined;
+            if (input?.file_path !== undefined) {
+              console.log(`    Edit: ${input.file_path}`);
+            }
+          }
+        }
+      }
+    }
+    if (message.type === 'result') {
+      const cost = message.total_cost_usd?.toFixed(4) ?? '?';
+      console.log(`    [Cost: $${cost}]`);
+    }
+  }
+
+  if (writeCount === 0) {
+    console.error('  Agent did not call Write — skill file not updated.');
+    return;
+  }
+
+  console.log(`  Wrote: ${skillRelPath} (${writeCount} Write + ${editCount} Edit calls)`);
+}

.github/scripts/doc-agent/src/review.ts

@@ -0,0 +1,232 @@
+/**
+ * Review mode: detect documentation drift in a git diff range.
+ *
+ * Used by the doc-review GitHub Action and locally for testing.
+ */
+
+import { execSync } from 'node:child_process';
+import { writeFile } from 'node:fs/promises';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { MODEL, XRPLD_ROOT } from './config.js';
+import { loadSystemPrompt } from './prompt-loader.js';
+import type { FileReviewResult, GitRange, ReviewIssue, ReviewOutput } from './types.js';
+
+const MAX_DIFF_CHARS = 12_000;
+const TRACKED_PATH_PATTERN = /^(include|src\/libxrpl|src\/xrpld)\//;
+const CPP_FILE_PATTERN = /\.(h|hpp|cpp)$/;
+
+/**
+ * Parse the CLI arguments into a base..head git range.
+ *
+ * Accepts either:
+ *   - `base..head` (e.g. `develop..HEAD`)
+ *   - `--pr <number>` (resolves via `gh pr view`)
+ */
+function parseRangeArgs(args: readonly string[]): GitRange {
+  const first = args[0];
+  if (first === undefined) {
+    throw new Error('Expected range as base..head or --pr <number>');
+  }
+
+  if (first === '--pr') {
+    const pr = args[1];
+    if (pr === undefined) {
+      throw new Error('--pr requires a PR number');
+    }
+    const base = execSync(`gh pr view ${pr} --json baseRefOid -q .baseRefOid`, {
+      cwd: XRPLD_ROOT,
+    })
+      .toString()
+      .trim();
+    const head = execSync(`gh pr view ${pr} --json headRefOid -q .headRefOid`, {
+      cwd: XRPLD_ROOT,
+    })
+      .toString()
+      .trim();
+    return { base, head };
+  }
+
+  const match = first.match(/^([^.]+)\.\.([^.]+)$/);
+  if (match === null || match[1] === undefined || match[2] === undefined) {
+    throw new Error('Expected range as base..head or --pr <number>');
+  }
+  return { base: match[1], head: match[2] };
+}
+
+/**
+ * Get the list of C++ source files changed in the given git range,
+ * filtered to paths the doc-agent cares about.
+ */
+function getChangedCppFiles(range: GitRange): string[] {
+  const out = execSync(`git diff --name-only ${range.base}...${range.head}`, {
+    cwd: XRPLD_ROOT,
+  }).toString();
+
+  return out
+    .split('\n')
+    .filter((line) => line.length > 0)
+    .filter((file) => CPP_FILE_PATTERN.test(file))
+    .filter((file) => TRACKED_PATH_PATTERN.test(file));
+}
+
+/** Get the unified diff for a single file in the given range. */
+function getFileDiff(range: GitRange, file: string): string {
+  return execSync(`git diff ${range.base}...${range.head} -- "${file}"`, {
+    cwd: XRPLD_ROOT,
+    maxBuffer: 10 * 1024 * 1024,
+  }).toString();
+}
+
+/** Extract a JSON object from a possibly-fenced model response. */
+function extractJson(response: string): ReviewOutput | null {
+  const fenced = response.match(/```json\s*([\s\S]*?)```/);
+  const raw = fenced?.[1] ?? response.match(/(\{[\s\S]*\})/)?.[1];
+  if (raw === undefined) return null;
+  try {
+    return JSON.parse(raw) as ReviewOutput;
+  } catch {
+    return null;
+  }
+}
+
+/** Send one file's diff to the agent and parse the response. */
+async function reviewFile(range: GitRange, file: string): Promise<FileReviewResult | null> {
+  console.log(`\n=== Reviewing: ${file} ===`);
+  const diff = getFileDiff(range, file);
+  if (diff.trim().length === 0) return null;
+
+  const systemPrompt = await loadSystemPrompt('review-diff', file);
+  const userPrompt = `Review this diff for documentation drift:
+
+## File: ${file}
+
+## Diff
+\`\`\`
+${diff.slice(0, MAX_DIFF_CHARS)}
+\`\`\`
+
+Use the Read tool to inspect the current state of the file, related tests,
+or callers if needed. Output findings as JSON per the schema in the system
+prompt.`;
+
+  let response = '';
+  const result = query({
+    prompt: userPrompt,
+    options: {
+      model: MODEL,
+      systemPrompt,
+      cwd: XRPLD_ROOT,
+      allowedTools: ['Read', 'Glob', 'Grep', 'Bash'],
+      permissionMode: 'acceptEdits',
+    },
+  });
+
+  for await (const message of result) {
+    if (message.type === 'assistant') {
+      const content = message.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'text') {
+            response += block.text;
+          }
+        }
+      }
+    }
+  }
+
+  const parsed = extractJson(response);
+  if (parsed === null) {
+    console.warn(`  No JSON output for ${file}, skipping`);
+    return null;
+  }
+
+  const issues: ReviewIssue[] = parsed.issues.map((issue) => ({
+    file: issue.file ?? file,
+    line: issue.line,
+    severity: issue.severity,
+    message: issue.message,
+    ...(issue.suggested_doc !== undefined && { suggestedDoc: issue.suggested_doc }),
+  }));
+
+  return { file, summary: parsed.summary, issues };
+}
+
+/** Build the markdown report posted to the PR. */
+function buildReport(fileCount: number, results: readonly FileReviewResult[]): string {
+  const issues = results.flatMap((r) => r.issues);
+  const warnings = issues.filter((i) => i.severity === 'warning').length;
+  const suggestions = issues.length - warnings;
+
+  const lines: string[] = ['## Documentation Review Report', ''];
+  lines.push(
+    issues.length === 0
+      ? 'No documentation issues found.'
+      : `Found **${issues.length}** issue(s) across **${fileCount}** changed file(s): ${warnings} warning(s), ${suggestions} suggestion(s).`,
+  );
+  lines.push('');
+
+  for (const result of results) {
+    if (result.issues.length === 0) continue;
+    lines.push(`### \`${result.file}\``, '', result.summary, '');
+    for (const issue of result.issues) {
+      const tag = issue.severity === 'warning' ? '**Warning:**' : '**Suggestion:**';
+      lines.push(`- ${tag} Line ${issue.line}: ${issue.message}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('---', '*Automated review by doc-agent.*');
+  return lines.join('\n');
+}
+
+/**
+ * Review the documentation drift introduced by a git range or PR.
+ *
+ * Writes two output files in the current working directory:
+ *   - doc-review-report.md (markdown summary for PR comment)
+ *   - doc-review-comments.json (inline review comments)
+ */
+export async function reviewDiff(args: readonly string[]): Promise<void> {
+  const range = parseRangeArgs(args);
+  console.log(`Reviewing range: ${range.base}...${range.head}`);
+
+  const files = getChangedCppFiles(range);
+  if (files.length === 0) {
+    console.log('No C++ files changed in this range.');
+    await writeFile('doc-review-report.md', '## Documentation Review\n\nNo C++ files changed.\n');
+    await writeFile('doc-review-comments.json', '[]');
+    return;
+  }
+
+  console.log(`Found ${files.length} changed C++ file(s).`);
+
+  const results: FileReviewResult[] = [];
+  for (const file of files) {
+    try {
+      const result = await reviewFile(range, file);
+      if (result !== null) results.push(result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`  Review failed for ${file}: ${message}`);
+    }
+  }
+
+  const report = buildReport(files.length, results);
+  const allIssues = results.flatMap((r) => r.issues);
+
+  // Shape inline comments for the GitHub pulls.createReviewComment API,
+  // which expects `path`/`line`/`body` rather than the internal field names.
+  const apiComments = allIssues.map((issue) => ({
+    path: issue.file,
+    line: issue.line,
+    body: issue.suggestedDoc
+      ? `**[${issue.severity}]** ${issue.message}\n\n\`\`\`cpp\n${issue.suggestedDoc}\n\`\`\``
+      : `**[${issue.severity}]** ${issue.message}`,
+  }));
+
+  await writeFile('doc-review-report.md', report);
+  await writeFile('doc-review-comments.json', JSON.stringify(apiComments, null, 2));
+
+  console.log('\nReport: doc-review-report.md');
+  console.log(`Inline comments: doc-review-comments.json (${apiComments.length} issues)`);
+}

.github/scripts/doc-agent/src/types.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared type definitions for the doc-agent.
+ */
+
+export type Severity = 'warning' | 'suggestion';
+
+export interface ReviewIssue {
+  file: string;
+  line: number;
+  severity: Severity;
+  message: string;
+  suggestedDoc?: string;
+}
+
+export interface FileReviewResult {
+  file: string;
+  summary: string;
+  issues: ReviewIssue[];
+}
+
+export interface ReviewOutput {
+  summary: string;
+  issues: Array<{
+    file?: string;
+    line: number;
+    severity: Severity;
+    message: string;
+    suggested_doc?: string;
+  }>;
+}
+
+export interface GitRange {
+  base: string;
+  head: string;
+}
+
+export type AgentMode = 'document' | 'review';

.github/scripts/doc-agent/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2023"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

.github/scripts/doc-coverage-check.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+Documentation coverage checker for xrpld.
+
+Parses coverxygen LCOV output, compares against per-module thresholds
+defined in .github/doc-coverage-thresholds.json, and generates a
+markdown report suitable for posting as a PR comment.
+
+Usage:
+    python3 doc-coverage-check.py \
+        --lcov-file doc-coverage.info \
+        --threshold-file .github/doc-coverage-thresholds.json \
+        --output doc-coverage-report.md \
+        [--base-lcov-file base-doc-coverage.info]
+"""
+
+import argparse
+import json
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+
+def parse_lcov(lcov_path: str) -> dict[str, dict[str, int]]:
+    """Parse LCOV-format file into per-file coverage data.
+
+    Returns a dict mapping file paths to {"documented": N, "total": N}.
+    """
+    coverage = {}
+    current_file = None
+    documented = 0
+    total = 0
+
+    with open(lcov_path) as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith("SF:"):
+                current_file = line[3:]
+                documented = 0
+                total = 0
+            elif line.startswith("DA:"):
+                parts = line[3:].split(",")
+                if len(parts) >= 2:
+                    total += 1
+                    if int(parts[1]) > 0:
+                        documented += 1
+            elif line == "end_of_record":
+                if current_file:
+                    coverage[current_file] = {
+                        "documented": documented,
+                        "total": total,
+                    }
+                current_file = None
+
+    return coverage
+
+
+def compute_module_coverage(
+    coverage: dict[str, dict[str, int]],
+    module_prefixes: list[str],
+) -> dict[str, dict[str, int | float]]:
+    """Aggregate file-level coverage into module-level stats."""
+    modules = {}
+    for prefix in module_prefixes:
+        doc = 0
+        tot = 0
+        for filepath, stats in coverage.items():
+            if filepath.startswith(prefix) or f"/{prefix}" in filepath:
+                doc += stats["documented"]
+                tot += stats["total"]
+        pct = (doc / tot * 100) if tot > 0 else 0.0
+        modules[prefix] = {"documented": doc, "total": tot, "percent": round(pct, 1)}
+    return modules
+
+
+def compute_global_coverage(
+    coverage: dict[str, dict[str, int]],
+) -> dict[str, int | float]:
+    """Compute overall coverage across all files."""
+    doc = sum(s["documented"] for s in coverage.values())
+    tot = sum(s["total"] for s in coverage.values())
+    pct = (doc / tot * 100) if tot > 0 else 0.0
+    return {"documented": doc, "total": tot, "percent": round(pct, 1)}
+
+
+def check_ratchet(
+    current: dict[str, dict[str, int | float]],
+    base: dict[str, dict[str, int | float]] | None,
+    current_global: dict[str, int | float],
+    base_global: dict[str, int | float] | None,
+) -> list[str]:
+    """Check that no module or global coverage decreased vs base branch."""
+    violations = []
+
+    if base_global and current_global["percent"] < base_global["percent"]:
+        violations.append(
+            f"Global coverage decreased: {base_global['percent']}% -> "
+            f"{current_global['percent']}%"
+        )
+
+    if base:
+        for module, stats in current.items():
+            if module in base and stats["percent"] < base[module]["percent"]:
+                violations.append(
+                    f"`{module}` coverage decreased: "
+                    f"{base[module]['percent']}% -> {stats['percent']}%"
+                )
+
+    return violations
+
+
+def check_new_files(
+    coverage: dict[str, dict[str, int]],
+    new_files: list[str],
+    min_coverage: int,
+) -> list[str]:
+    """Check that new files meet minimum documentation coverage."""
+    violations = []
+    for filepath in new_files:
+        for covered_path, stats in coverage.items():
+            if filepath in covered_path or covered_path.endswith(filepath):
+                if stats["total"] > 0:
+                    pct = stats["documented"] / stats["total"] * 100
+                    if pct < min_coverage:
+                        violations.append(
+                            f"`{filepath}` has {pct:.0f}% doc coverage "
+                            f"(minimum {min_coverage}%)"
+                        )
+                break
+    return violations
+
+
+def coverage_emoji(pct: float) -> str:
+    if pct >= 80:
+        return "+"
+    if pct >= 50:
+        return "~"
+    return "-"
+
+
+def generate_report(
+    global_stats: dict[str, int | float],
+    module_stats: dict[str, dict[str, int | float]],
+    thresholds: dict,
+    violations: list[str],
+    new_file_violations: list[str],
+) -> str:
+    """Generate a markdown report for the PR comment."""
+    lines = []
+    lines.append("## Documentation Coverage Report")
+    lines.append("")
+
+    passed = not violations and not new_file_violations
+    status = "PASSED" if passed else "FAILED"
+    lines.append(f"**Status:** {status}")
+    lines.append(
+        f"**Global Coverage:** {global_stats['percent']}% "
+        f"({global_stats['documented']}/{global_stats['total']} entities documented)"
+    )
+    lines.append(
+        f"**Minimum Threshold:** {thresholds.get('global_minimum', 0)}%"
+    )
+    lines.append("")
+
+    if violations or new_file_violations:
+        lines.append("### Violations")
+        lines.append("")
+        for v in violations + new_file_violations:
+            lines.append(f"- {v}")
+        lines.append("")
+
+    lines.append("### Module Coverage")
+    lines.append("")
+    lines.append("| Module | Coverage | Documented | Total | Threshold |")
+    lines.append("|--------|----------|------------|-------|-----------|")
+
+    module_thresholds = thresholds.get("module_thresholds", {})
+    for module in sorted(module_stats.keys()):
+        stats = module_stats[module]
+        threshold = module_thresholds.get(module, 0)
+        emoji = coverage_emoji(stats["percent"])
+        lines.append(
+            f"| `{module}` | {stats['percent']}% | "
+            f"{stats['documented']} | {stats['total']} | {threshold}% |"
+        )
+
+    lines.append("")
+    lines.append(
+        "*Coverage measured by [coverxygen](https://github.com/psycofdj/coverxygen). "
+        "See [docs/DOCUMENTATION_STANDARDS.md](../docs/DOCUMENTATION_STANDARDS.md) "
+        "for documentation guidelines.*"
+    )
+
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Check documentation coverage")
+    parser.add_argument("--lcov-file", required=True, help="Path to LCOV coverage file")
+    parser.add_argument(
+        "--threshold-file", required=True, help="Path to thresholds JSON"
+    )
+    parser.add_argument("--output", required=True, help="Path to write markdown report")
+    parser.add_argument(
+        "--base-lcov-file", default=None, help="Path to base branch LCOV file"
+    )
+    parser.add_argument(
+        "--new-files",
+        default="",
+        help="Comma-separated list of new C++ files in this PR",
+    )
+    args = parser.parse_args()
+
+    with open(args.threshold_file) as f:
+        thresholds = json.load(f)
+
+    coverage = parse_lcov(args.lcov_file)
+    module_prefixes = list(thresholds.get("module_thresholds", {}).keys())
+    module_stats = compute_module_coverage(coverage, module_prefixes)
+    global_stats = compute_global_coverage(coverage)
+
+    base_coverage = None
+    base_module_stats = None
+    base_global_stats = None
+    if args.base_lcov_file and Path(args.base_lcov_file).exists():
+        base_coverage = parse_lcov(args.base_lcov_file)
+        base_module_stats = compute_module_coverage(base_coverage, module_prefixes)
+        base_global_stats = compute_global_coverage(base_coverage)
+
+    violations = []
+
+    if global_stats["percent"] < thresholds.get("global_minimum", 0):
+        violations.append(
+            f"Global coverage {global_stats['percent']}% is below minimum "
+            f"{thresholds['global_minimum']}%"
+        )
+
+    for module, threshold in thresholds.get("module_thresholds", {}).items():
+        if module in module_stats and module_stats[module]["percent"] < threshold:
+            violations.append(
+                f"`{module}` coverage {module_stats[module]['percent']}% is below "
+                f"threshold {threshold}%"
+            )
+
+    if thresholds.get("ratchet_mode") == "no_decrease":
+        violations.extend(
+            check_ratchet(
+                module_stats, base_module_stats, global_stats, base_global_stats
+            )
+        )
+
+    new_file_violations = []
+    if args.new_files:
+        new_files = [f.strip() for f in args.new_files.split(",") if f.strip()]
+        new_file_min = thresholds.get("new_file_minimum", 80)
+        new_file_violations = check_new_files(coverage, new_files, new_file_min)
+
+    report = generate_report(
+        global_stats, module_stats, thresholds, violations, new_file_violations
+    )
+
+    with open(args.output, "w") as f:
+        f.write(report)
+
+    print(report)
+
+    if violations or new_file_violations:
+        print(f"\nFAILED: {len(violations) + len(new_file_violations)} violation(s)")
+        sys.exit(1)
+    else:
+        print("\nPASSED: All coverage thresholds met")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

.github/scripts/levelization/README.md

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

.github/scripts/levelization/generate.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+
+"""
+Usage: generate.py
+This script takes no parameters, and can be called from any directory in the file system.
+"""
+
+import os
+import re
+import subprocess
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Tuple, Set, Optional
+
+# Compile regex patterns once at module level
+INCLUDE_PATTERN = re.compile(r"^\s*#include.*/.*\.h")
+INCLUDE_PATH_PATTERN = re.compile(r'[<"]([^>"]+)[>"]')
+
+
+def dictionary_sort_key(s: str) -> str:
+    """
+    Create a sort key that mimics 'sort -d' (dictionary order).
+    Dictionary order only considers blanks and alphanumeric characters.
+    This means punctuation like '.' is ignored during sorting.
+    """
+    # Keep only alphanumeric characters and spaces
+    return "".join(c for c in s if c.isalnum() or c.isspace())
+
+
+def get_level(file_path: str) -> str:
+    """
+    Extract the level from a file path (second and third directory components).
+    Equivalent to bash: cut -d/ -f 2,3
+
+    Examples:
+        src/xrpld/app/main.cpp -> xrpld.app
+        src/libxrpl/protocol/STObject.cpp -> libxrpl.protocol
+        include/xrpl/basics/base_uint.h -> xrpl.basics
+    """
+    parts = file_path.split("/")
+
+    # Get fields 2 and 3 (indices 1 and 2 in 0-based indexing)
+    if len(parts) >= 3:
+        level = f"{parts[1]}/{parts[2]}"
+    elif len(parts) >= 2:
+        level = f"{parts[1]}/toplevel"
+    else:
+        level = file_path
+
+    # If the "level" indicates a file, cut off the filename
+    if "." in level.split("/")[-1]:  # Avoid Path object creation
+        # Use the "toplevel" label as a workaround for `sort`
+        # inconsistencies between different utility versions
+        level = level.rsplit("/", 1)[0] + "/toplevel"
+
+    return level.replace("/", ".")
+
+
+def extract_include_level(include_line: str) -> Optional[str]:
+    """
+    Extract the include path from an #include directive.
+    Gets the first two directory components from the include path.
+    Equivalent to bash: cut -d/ -f 1,2
+
+    Examples:
+        #include <xrpl/basics/base_uint.h> -> xrpl.basics
+        #include "xrpld/app/main/Application.h" -> xrpld.app
+    """
+    # Remove everything before the quote or angle bracket
+    match = INCLUDE_PATH_PATTERN.search(include_line)
+    if not match:
+        return None
+
+    include_path = match.group(1)
+    parts = include_path.split("/")
+
+    # Get first two fields (indices 0 and 1)
+    if len(parts) >= 2:
+        include_level = f"{parts[0]}/{parts[1]}"
+    else:
+        include_level = include_path
+
+    # If the "includelevel" indicates a file, cut off the filename
+    if "." in include_level.split("/")[-1]:  # Avoid Path object creation
+        include_level = include_level.rsplit("/", 1)[0] + "/toplevel"
+
+    return include_level.replace("/", ".")
+
+
+def find_repository_directories(
+    start_path: Path, depth_limit: int = 10
+) -> Tuple[Path, List[Path]]:
+    """
+    Find the repository root by looking for src or include folders.
+    Walks up the directory tree from the start path.
+    """
+    current = start_path.resolve()
+
+    # Walk up the directory tree
+    for _ in range(depth_limit):  # Limit search depth to prevent infinite loops
+        src_path = current / "src"
+        include_path = current / "include"
+        # Check if this directory has src or include folders
+        has_src = src_path.exists()
+        has_include = include_path.exists()
+
+        if has_src or has_include:
+            return current, [src_path, include_path]
+
+        # Move up one level
+        parent = current.parent
+        if parent == current:  # Reached filesystem root
+            break
+        current = parent
+
+    # If we couldn't find it, raise an error
+    raise RuntimeError(
+        "Could not find repository root. "
+        "Expected to find a directory containing 'src' and/or 'include' folders."
+    )
+
+
+def main():
+    # Change to the script's directory
+    script_dir = Path(__file__).parent.resolve()
+    os.chdir(script_dir)
+
+    # Clean up and create results directory.
+    results_dir = script_dir / "results"
+    if results_dir.exists():
+        import shutil
+
+        shutil.rmtree(results_dir)
+    results_dir.mkdir()
+
+    # Find the repository root by searching for src and include directories.
+    try:
+        repo_root, scan_dirs = find_repository_directories(script_dir)
+
+        print(f"Found repository root: {repo_root}")
+        print(f"Scanning directories:")
+        for scan_dir in scan_dirs:
+            print(f"  - {scan_dir.relative_to(repo_root)}")
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print("\nScanning for raw includes...")
+    # Find all #include directives
+    raw_includes: List[Tuple[str, str]] = []
+    rawincludes_file = results_dir / "rawincludes.txt"
+
+    # Write to file as we go to avoid storing everything in memory.
+    with open(rawincludes_file, "w", buffering=8192) as raw_f:
+        for dir_path in scan_dirs:
+            print(f"  Scanning {dir_path.relative_to(repo_root)}...")
+
+            for file_path in dir_path.rglob("*"):
+                if not file_path.is_file():
+                    continue
+
+                try:
+                    rel_path_str = str(file_path.relative_to(repo_root))
+
+                    # Read file with a large buffer for performance.
+                    with open(
+                        file_path,
+                        "r",
+                        encoding="utf-8",
+                        errors="ignore",
+                        buffering=8192,
+                    ) as f:
+                        for line in f:
+                            # Quick check before regex
+                            if "#include" not in line or "boost" in line:
+                                continue
+
+                            if INCLUDE_PATTERN.match(line):
+                                line_stripped = line.strip()
+                                entry = f"{rel_path_str}:{line_stripped}\n"
+                                print(entry, end="")
+                                raw_f.write(entry)
+                                raw_includes.append((rel_path_str, line_stripped))
+                except Exception as e:
+                    print(f"Error reading {file_path}: {e}", file=sys.stderr)
+
+    # Build levelization paths and count directly (no need to sort first).
+    print("Build levelization paths")
+    path_counts: Dict[Tuple[str, str], int] = defaultdict(int)
+
+    for file_path, include_line in raw_includes:
+        include_level = extract_include_level(include_line)
+        if not include_level:
+            continue
+
+        level = get_level(file_path)
+        if level != include_level:
+            path_counts[(level, include_level)] += 1
+
+    # Sort and deduplicate paths (using dictionary order like bash 'sort -d').
+    print("Sort and deduplicate paths")
+
+    paths_file = results_dir / "paths.txt"
+    with open(paths_file, "w") as f:
+        # Sort using dictionary order: only alphanumeric and spaces matter
+        sorted_items = sorted(
+            path_counts.items(),
+            key=lambda x: (dictionary_sort_key(x[0][0]), dictionary_sort_key(x[0][1])),
+        )
+        for (level, include_level), count in sorted_items:
+            line = f"{count:7} {level} {include_level}\n"
+            print(line.rstrip())
+            f.write(line)
+
+    # Split into flat-file database
+    print("Split into flat-file database")
+    includes_dir = results_dir / "includes"
+    included_by_dir = results_dir / "included_by"
+    includes_dir.mkdir()
+    included_by_dir.mkdir()
+
+    # Batch writes by grouping data first to avoid repeated file opens.
+    includes_data: Dict[str, List[Tuple[str, int]]] = defaultdict(list)
+    included_by_data: Dict[str, List[Tuple[str, int]]] = defaultdict(list)
+
+    # Process in sorted order to match bash script behaviour (dictionary order).
+    sorted_items = sorted(
+        path_counts.items(),
+        key=lambda x: (dictionary_sort_key(x[0][0]), dictionary_sort_key(x[0][1])),
+    )
+    for (level, include_level), count in sorted_items:
+        includes_data[level].append((include_level, count))
+        included_by_data[include_level].append((level, count))
+
+    # Write all includes files in sorted order (dictionary order).
+    for level in sorted(includes_data.keys(), key=dictionary_sort_key):
+        entries = includes_data[level]
+        with open(includes_dir / level, "w") as f:
+            for include_level, count in entries:
+                line = f"{include_level} {count}\n"
+                print(line.rstrip())
+                f.write(line)
+
+    # Write all included_by files in sorted order (dictionary order).
+    for include_level in sorted(included_by_data.keys(), key=dictionary_sort_key):
+        entries = included_by_data[include_level]
+        with open(included_by_dir / include_level, "w") as f:
+            for level, count in entries:
+                line = f"{level} {count}\n"
+                print(line.rstrip())
+                f.write(line)
+
+    # Search for loops
+    print("Search for loops")
+    loops_file = results_dir / "loops.txt"
+    ordering_file = results_dir / "ordering.txt"
+
+    loops_found: Set[Tuple[str, str]] = set()
+
+    # Pre-load all include files into memory to avoid repeated I/O.
+    # This is the biggest optimisation - we were reading files repeatedly in nested loops.
+    # Use list of tuples to preserve file order.
+    includes_cache: Dict[str, List[Tuple[str, int]]] = {}
+    includes_lookup: Dict[str, Dict[str, int]] = {}  # For fast lookup
+
+    # Note: bash script uses 'for source in *' which uses standard glob sorting,
+    # NOT dictionary order. So we use standard sorted() here, not dictionary_sort_key.
+    for include_file in sorted(includes_dir.iterdir(), key=lambda p: p.name):
+        if not include_file.is_file():
+            continue
+
+        includes_cache[include_file.name] = []
+        includes_lookup[include_file.name] = {}
+        with open(include_file, "r") as f:
+            for line in f:
+                parts = line.strip().split()
+                if len(parts) >= 2:
+                    include_name = parts[0]
+                    include_count = int(parts[1])
+                    includes_cache[include_file.name].append(
+                        (include_name, include_count)
+                    )
+                    includes_lookup[include_file.name][include_name] = include_count
+
+    with open(loops_file, "w", buffering=8192) as loops_f, open(
+        ordering_file, "w", buffering=8192
+    ) as ordering_f:
+
+        # Use standard sorting to match bash glob expansion 'for source in *'.
+        for source in sorted(includes_cache.keys()):
+            source_includes = includes_cache[source]
+
+            for include, include_freq in source_includes:
+                # Check if include file exists and references source
+                if include not in includes_lookup:
+                    continue
+
+                source_freq = includes_lookup[include].get(source)
+
+                if source_freq is not None:
+                    # Found a loop
+                    loop_key = tuple(sorted([source, include]))
+                    if loop_key in loops_found:
+                        continue
+                    loops_found.add(loop_key)
+
+                    loops_f.write(f"Loop: {source} {include}\n")
+
+                    # If the counts are close, indicate that the two modules are
+                    # on the same level, though they shouldn't be.
+                    diff = include_freq - source_freq
+                    if diff > 3:
+                        loops_f.write(f"  {source} > {include}\n\n")
+                    elif diff < -3:
+                        loops_f.write(f"  {include} > {source}\n\n")
+                    elif source_freq == include_freq:
+                        loops_f.write(f"  {include} == {source}\n\n")
+                    else:
+                        loops_f.write(f"  {include} ~= {source}\n\n")
+                else:
+                    ordering_f.write(f"{source} > {include}\n")
+
+    # Print results
+    print("\nOrdering:")
+    with open(ordering_file, "r") as f:
+        print(f.read(), end="")
+
+    print("\nLoops:")
+    with open(loops_file, "r") as f:
+        print(f.read(), end="")
+
+
+if __name__ == "__main__":
+    main()

.github/scripts/levelization/results/loops.txt

@@ -0,0 +1,21 @@
+Loop: test.jtx test.toplevel
+  test.toplevel > test.jtx
+
+Loop: test.jtx test.unit_test
+  test.unit_test ~= test.jtx
+
+Loop: xrpld.app xrpld.overlay
+  xrpld.app > xrpld.overlay
+
+Loop: xrpld.app xrpld.peerfinder
+  xrpld.peerfinder ~= xrpld.app
+
+Loop: xrpld.app xrpld.rpc
+  xrpld.rpc > xrpld.app
+
+Loop: xrpld.app xrpld.shamap
+  xrpld.shamap > xrpld.app
+
+Loop: xrpld.overlay xrpld.rpc
+  xrpld.rpc ~= xrpld.overlay
+

.github/scripts/levelization/results/ordering.txt

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

.github/scripts/rename/README.md

@@ -0,0 +1,50 @@
+## Renaming ripple(d) to xrpl(d)
+
+In the initial phases of development of the XRPL, the open source codebase was
+called "rippled" and it remains with that name even today. Today, over 1000
+nodes run the application, and code contributions have been submitted by
+developers located around the world. The XRPL community is larger than ever.
+In light of the decentralized and diversified nature of XRPL, we will rename any
+references to `ripple` and `rippled` to `xrpl` and `xrpld`, when appropriate.
+
+See [here](https://xls.xrpl.org/xls/XLS-0095-rename-rippled-to-xrpld.html) for
+more information.
+
+### Scripts
+
+To facilitate this transition, there will be multiple scripts that developers
+can run on their own PRs and forks to minimize conflicts. Each script should be
+run from the repository root.
+
+1. `.github/scripts/rename/definitions.sh`: This script will rename all
+   definitions, such as include guards, from `RIPPLE_XXX` and `RIPPLED_XXX` to
+   `XRPL_XXX`.
+2. `.github/scripts/rename/copyright.sh`: This script will remove superfluous
+   copyright notices.
+3. `.github/scripts/rename/cmake.sh`: This script will rename all CMake files
+   from `RippleXXX.cmake` or `RippledXXX.cmake` to `XrplXXX.cmake`, and any
+   references to `ripple` and `rippled` (with or without capital letters) to
+   `xrpl` and `xrpld`, respectively. The name of the binary will remain as-is,
+   and will only be renamed to `xrpld` by a later script.
+4. `.github/scripts/rename/binary.sh`: This script will rename the binary from
+   `rippled` to `xrpld`, and reverses the symlink so that `rippled` points to
+   the `xrpld` binary.
+5. `.github/scripts/rename/namespace.sh`: This script will rename the C++
+   namespaces from `ripple` to `xrpl`.
+6. `.github/scripts/rename/config.sh`: This script will rename the config from
+   `rippled.cfg` to `xrpld.cfg`, and updating the code accordingly. The old
+   filename will still be accepted.
+7. `.github/scripts/rename/docs.sh`: This script will rename any lingering
+   references of `ripple(d)` to `xrpl(d)` in code, comments, and documentation.
+
+You can run all these scripts from the repository root as follows:
+
+```shell
+./.github/scripts/rename/definitions.sh .
+./.github/scripts/rename/copyright.sh .
+./.github/scripts/rename/cmake.sh .
+./.github/scripts/rename/binary.sh .
+./.github/scripts/rename/namespace.sh .
+./.github/scripts/rename/config.sh .
+./.github/scripts/rename/docs.sh .
+```

.github/scripts/rename/binary.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -e
+
+# On MacOS, ensure that GNU sed is installed and available as `gsed`.
+SED_COMMAND=sed
+if [[ "${OSTYPE}" == 'darwin'* ]]; then
+    if ! command -v gsed &> /dev/null; then
+        echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
+        exit 1
+    fi
+    SED_COMMAND=gsed
+fi
+
+# This script changes the binary name from `rippled` to `xrpld`, and reverses
+# the symlink that currently points from `xrpld` to `rippled` so that it points
+# from `rippled` to `xrpld` instead.
+# Usage: .github/scripts/rename/binary.sh <repository directory>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <repository directory>"
+    exit 1
+fi
+
+DIRECTORY=$1
+echo "Processing directory: ${DIRECTORY}"
+if [ ! -d "${DIRECTORY}" ]; then
+    echo "Error: Directory '${DIRECTORY}' does not exist."
+    exit 1
+fi
+pushd "${DIRECTORY}"
+
+# Remove the binary name override added by the cmake.sh script.
+${SED_COMMAND} -z -i -E 's@\s+# For the time being.+"rippled"\)@@' cmake/XrplCore.cmake
+
+# Reverse the symlink.
+${SED_COMMAND} -i -E 's@create_symbolic_link\(rippled@create_symbolic_link(xrpld@' cmake/XrplInstall.cmake
+${SED_COMMAND} -i -E 's@/xrpld\$\{suffix\}@/rippled${suffix}@' cmake/XrplInstall.cmake
+
+# Rename references to the binary.
+${SED_COMMAND} -i -E 's@rippled@xrpld@g' BUILD.md
+${SED_COMMAND} -i -E 's@rippled@xrpld@g' CONTRIBUTING.md
+${SED_COMMAND} -i -E 's@rippled@xrpld@g' .github/ISSUE_TEMPLATE/bug_report.md
+
+# Restore and/or fix certain renames. The pre-commit hook will update the
+# formatting upon saving/committing.
+${SED_COMMAND} -i -E 's@ripple/xrpld@XRPLF/rippled@g' BUILD.md
+${SED_COMMAND} -i -E 's@XRPLF/xrpld@XRPLF/rippled@g' BUILD.md
+${SED_COMMAND} -i -E 's@xrpld \(`xrpld`\)@xrpld@g' BUILD.md
+${SED_COMMAND} -i -E 's@XRPLF/xrpld@XRPLF/rippled@g' CONTRIBUTING.md
+${SED_COMMAND} -i -E 's@XRPLF/xrpld@XRPLF/rippled@g' docs/build/install.md
+
+popd
+echo "Processing complete."

.github/scripts/rename/cmake.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -e
+
+# On MacOS, ensure that GNU sed and head are installed and available as `gsed`
+# and `ghead`, respectively.
+SED_COMMAND=sed
+HEAD_COMMAND=head
+if [[ "${OSTYPE}" == 'darwin'* ]]; then
+    if ! command -v gsed &> /dev/null; then
+        echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
+        exit 1
+    fi
+    SED_COMMAND=gsed
+    if ! command -v ghead &> /dev/null; then
+        echo "Error: ghead is not installed. Please install it using 'brew install coreutils'."
+        exit 1
+    fi
+    HEAD_COMMAND=ghead
+fi
+
+# This script renames CMake files from `RippleXXX.cmake` or `RippledXXX.cmake`
+# to `XrplXXX.cmake`, and any references to `ripple` and `rippled` (with or
+# without capital letters) to `xrpl` and `xrpld`, respectively. The name of the
+# binary will remain as-is, and will only be renamed to `xrpld` in a different
+# script, but the proto file will be renamed.
+# Usage: .github/scripts/rename/cmake.sh <repository directory>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <repository directory>"
+    exit 1
+fi
+
+DIRECTORY=$1
+echo "Processing directory: ${DIRECTORY}"
+if [ ! -d "${DIRECTORY}" ]; then
+    echo "Error: Directory '${DIRECTORY}' does not exist."
+    exit 1
+fi
+pushd "${DIRECTORY}"
+
+# Rename the files.
+find cmake -type f -name 'Rippled*.cmake' -exec bash -c 'mv "${1}" "${1/Rippled/Xrpl}"' - {} \;
+find cmake -type f -name 'Ripple*.cmake' -exec bash -c 'mv "${1}" "${1/Ripple/Xrpl}"' - {} \;
+if [ -e cmake/xrpl_add_test.cmake ]; then
+    mv cmake/xrpl_add_test.cmake cmake/XrplAddTest.cmake
+fi
+if [ -e include/xrpl/proto/ripple.proto ]; then
+    mv include/xrpl/proto/ripple.proto include/xrpl/proto/xrpl.proto
+fi
+
+# Rename inside the files.
+find cmake -type f -name '*.cmake' | while read -r FILE; do
+    echo "Processing file: ${FILE}"
+    ${SED_COMMAND} -i 's/Rippled/Xrpld/g' "${FILE}"
+    ${SED_COMMAND} -i 's/Ripple/Xrpl/g' "${FILE}"
+    ${SED_COMMAND} -i 's/rippled/xrpld/g' "${FILE}"
+    ${SED_COMMAND} -i 's/ripple/xrpl/g' "${FILE}"
+done
+${SED_COMMAND} -i -E 's/Rippled?/Xrpl/g' CMakeLists.txt
+${SED_COMMAND} -i 's/ripple/xrpl/g' CMakeLists.txt
+${SED_COMMAND} -i 's/include(xrpl_add_test)/include(XrplAddTest)/' src/tests/libxrpl/CMakeLists.txt
+${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' include/xrpl/protocol/messages.h
+${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' BUILD.md
+${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' BUILD.md
+
+# Restore the name of the validator keys repository.
+${SED_COMMAND} -i 's@xrpl/validator-keys-tool@ripple/validator-keys-tool@' cmake/XrplValidatorKeys.cmake
+
+# Ensure the name of the binary and config remain 'rippled' for now.
+${SED_COMMAND} -i -E 's/xrpld(-example)?\.cfg/rippled\1.cfg/g' cmake/XrplInstall.cmake
+if grep -q '"xrpld"' cmake/XrplCore.cmake; then
+    # The script has been rerun, so just restore the name of the binary.
+    ${SED_COMMAND} -i 's/"xrpld"/"rippled"/' cmake/XrplCore.cmake
+elif ! grep -q '"rippled"' cmake/XrplCore.cmake; then
+    ${HEAD_COMMAND} -n -1 cmake/XrplCore.cmake > cmake.tmp
+    echo '  # For the time being, we will keep the name of the binary as it was.' >> cmake.tmp
+    echo '  set_target_properties(xrpld PROPERTIES OUTPUT_NAME "rippled")' >> cmake.tmp
+    tail -1 cmake/XrplCore.cmake >> cmake.tmp
+    mv cmake.tmp cmake/XrplCore.cmake
+fi
+
+# Restore the symlink from 'xrpld' to 'rippled'.
+${SED_COMMAND} -i -E 's@create_symbolic_link\(xrpld@create_symbolic_link(rippled@' cmake/XrplInstall.cmake
+
+# Remove the symlink that previously pointed from 'ripple' to 'xrpl' but now is
+# no longer needed.
+${SED_COMMAND} -z -i -E 's@install\(CODE.+CMAKE_INSTALL_INCLUDEDIR}/xrpl\)\n"\)\n+@@' cmake/XrplInstall.cmake
+
+popd
+echo "Renaming complete."

.github/scripts/rename/config.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -e
+
+# On MacOS, ensure that GNU sed is installed and available as `gsed`.
+SED_COMMAND=sed
+if [[ "${OSTYPE}" == 'darwin'* ]]; then
+    if ! command -v gsed &> /dev/null; then
+        echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
+        exit 1
+    fi
+    SED_COMMAND=gsed
+fi
+
+# This script renames the config from `rippled.cfg` to `xrpld.cfg`, and updates
+# the code accordingly. The old filename will still be accepted.
+# Usage: .github/scripts/rename/config.sh <repository directory>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <repository directory>"
+    exit 1
+fi
+
+DIRECTORY=$1
+echo "Processing directory: ${DIRECTORY}"
+if [ ! -d "${DIRECTORY}" ]; then
+    echo "Error: Directory '${DIRECTORY}' does not exist."
+    exit 1
+fi
+pushd "${DIRECTORY}"
+
+# Add the xrpld.cfg to the .gitignore.
+if ! grep -q 'xrpld.cfg' .gitignore; then
+    ${SED_COMMAND} -i '/rippled.cfg/a\
+/xrpld.cfg' .gitignore
+fi
+
+# Rename the files.
+if [ -e rippled.cfg ]; then
+    mv rippled.cfg xrpld.cfg
+fi
+if [ -e cfg/rippled-example.cfg ]; then
+    mv cfg/rippled-example.cfg cfg/xrpld-example.cfg
+fi
+
+# Rename inside the files.
+DIRECTORIES=("cfg" "cmake" "include" "src")
+for DIRECTORY in "${DIRECTORIES[@]}"; do
+    echo "Processing directory: ${DIRECTORY}"
+
+    find "${DIRECTORY}" -type f \( -name "*.h" -o -name "*.hpp" -o -name "*.ipp" -o -name "*.cpp" -o -name "*.cmake" -o -name "*.txt" -o -name "*.cfg" -o -name "*.md" \) | while read -r FILE; do
+        echo "Processing file: ${FILE}"
+        ${SED_COMMAND} -i -E 's/rippled(-example)?[ .]cfg/xrpld\1.cfg/g' "${FILE}"
+        ${SED_COMMAND} -i 's/rippleConfig/xrpldConfig/g' "${FILE}"
+    done
+done
+${SED_COMMAND} -i 's/rippled/xrpld/g' cfg/xrpld-example.cfg
+${SED_COMMAND} -i 's/rippled/xrpld/g' src/test/core/Config_test.cpp
+${SED_COMMAND} -i 's/ripplevalidators/xrplvalidators/g' src/test/core/Config_test.cpp # cspell: disable-line
+${SED_COMMAND} -i 's@ripple/@xrpld/@g' src/test/core/Config_test.cpp
+${SED_COMMAND} -i 's/Rippled/File/g' src/test/core/Config_test.cpp
+
+# Restore the old config file name in the code that maintains support for now.
+${SED_COMMAND} -i 's/kCONFIG_LEGACY_NAME = "xrpld.cfg"/kCONFIG_LEGACY_NAME = "rippled.cfg"/g' src/xrpld/core/detail/Config.cpp
+
+# Restore an URL.
+${SED_COMMAND} -i 's/connect-your-xrpld-to-the-xrp-test-net.html/connect-your-rippled-to-the-xrp-test-net.html/g' cfg/xrpld-example.cfg
+
+popd
+echo "Renaming complete."

.github/scripts/rename/copyright.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -e
+
+# On MacOS, ensure that GNU sed is installed and available as `gsed`.
+SED_COMMAND=sed
+if [[ "${OSTYPE}" == 'darwin'* ]]; then
+    if ! command -v gsed &> /dev/null; then
+        echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
+        exit 1
+    fi
+    SED_COMMAND=gsed
+fi
+
+# This script removes superfluous copyright notices in source and header files
+# in this project. Specifically, it removes all notices referencing Ripple,
+# XRPLF, and certain individual contributors upon mutual agreement, so the one
+# in the LICENSE.md file applies throughout. Copyright notices referencing
+# external contributions, e.g. from Bitcoin, remain as-is.
+# Usage: .github/scripts/rename/copyright.sh <repository directory>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <repository directory>"
+    exit 1
+fi
+
+DIRECTORY=$1
+echo "Processing directory: ${DIRECTORY}"
+if [ ! -d "${DIRECTORY}" ]; then
+    echo "Error: Directory '${DIRECTORY}' does not exist."
+    exit 1
+fi
+pushd "${DIRECTORY}"
+
+# Prevent sed and echo from removing newlines and tabs in string literals by
+# temporarily replacing them with placeholders. This only affects one file.
+PLACEHOLDER_NEWLINE="__NEWLINE__"
+PLACEHOLDER_TAB="__TAB__"
+${SED_COMMAND} -i -E "s@\\\n@${PLACEHOLDER_NEWLINE}@g" src/test/rpc/ValidatorInfo_test.cpp
+${SED_COMMAND} -i -E "s@\\\t@${PLACEHOLDER_TAB}@g" src/test/rpc/ValidatorInfo_test.cpp
+
+# Process the include/ and src/ directories.
+DIRECTORIES=("include" "src")
+for DIRECTORY in "${DIRECTORIES[@]}"; do
+    echo "Processing directory: ${DIRECTORY}"
+
+    find "${DIRECTORY}" -type f \( -name "*.h" -o -name "*.hpp" -o -name "*.ipp" -o -name "*.cpp" -o -name "*.macro" \) | while read -r FILE; do
+        echo "Processing file: ${FILE}"
+        # Handle the cases where the copyright notice is enclosed in /* ... */
+        # and usually surrounded by //---- and //======.
+        ${SED_COMMAND} -z -i -E 's@^//-------+\n+@@' "${FILE}"
+        ${SED_COMMAND} -z -i -E 's@^.*Copyright.+(Ripple|Bougalis|Falco|Hinnant|Null|Ritchford|XRPLF).+PERFORMANCE OF THIS SOFTWARE\.\n\*/\n+@@' "${FILE}" # cspell: ignore Bougalis Falco Hinnant Ritchford
+        ${SED_COMMAND} -z -i -E 's@^//=======+\n+@@' "${FILE}"
+
+        # Handle the cases where the copyright notice is commented out with //.
+        ${SED_COMMAND} -z -i -E 's@^//\n// Copyright.+Falco \(vinnie dot falco at gmail dot com\)\n//\n+@@' "${FILE}" # cspell: ignore Vinnie Falco
+    done
+done
+
+# Restore copyright notices that were removed from specific files, without
+# restoring the verbiage that is already present in LICENSE.md. Ensure that if
+# the script is run multiple times, duplicate notices are not added.
+if ! grep -q 'Raw Material Software' include/xrpl/beast/core/CurrentThreadName.h; then
+    echo -e "// Portions of this file are from JUCE (http://www.juce.com).\n// Copyright (c) 2013 - Raw Material Software Ltd.\n// Please visit http://www.juce.com\n\n$(cat include/xrpl/beast/core/CurrentThreadName.h)" > include/xrpl/beast/core/CurrentThreadName.h
+fi
+if ! grep -q 'Dev Null' src/test/app/NetworkID_test.cpp; then
+    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/app/NetworkID_test.cpp)" > src/test/app/NetworkID_test.cpp
+fi
+if ! grep -q 'Dev Null' src/test/app/tx/apply_test.cpp; then
+    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/app/tx/apply_test.cpp)" > src/test/app/tx/apply_test.cpp
+fi
+if ! grep -q 'Dev Null' src/test/rpc/ManifestRPC_test.cpp; then
+    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/rpc/ManifestRPC_test.cpp)" > src/test/rpc/ManifestRPC_test.cpp
+fi
+if ! grep -q 'Dev Null' src/test/rpc/ValidatorInfo_test.cpp; then
+    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/rpc/ValidatorInfo_test.cpp)" > src/test/rpc/ValidatorInfo_test.cpp
+fi
+if ! grep -q 'Dev Null' src/xrpld/rpc/handlers/server_info/Manifest.cpp; then
+    echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/server_info/Manifest.cpp)" > src/xrpld/rpc/handlers/server_info/Manifest.cpp
+fi
+if ! grep -q 'Dev Null' src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp; then
+    echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp)" > src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp
+fi
+if ! grep -q 'Bougalis' include/xrpl/basics/SlabAllocator.h; then
+    echo -e "// Copyright (c) 2022, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/SlabAllocator.h)" > include/xrpl/basics/SlabAllocator.h # cspell: ignore Nikolaos Bougalis nikb
+fi
+if ! grep -q 'Bougalis' include/xrpl/basics/spinlock.h; then
+    echo -e "// Copyright (c) 2022, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/spinlock.h)" > include/xrpl/basics/spinlock.h # cspell: ignore Nikolaos Bougalis nikb
+fi
+if ! grep -q 'Bougalis' include/xrpl/basics/tagged_integer.h; then
+    echo -e "// Copyright (c) 2014, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/tagged_integer.h)" > include/xrpl/basics/tagged_integer.h # cspell: ignore Nikolaos Bougalis nikb
+fi
+if ! grep -q 'Ritchford' include/xrpl/beast/utility/Zero.h; then
+    echo -e "// Copyright (c) 2014, Tom Ritchford <tom@swirly.com>\n\n$(cat include/xrpl/beast/utility/Zero.h)" > include/xrpl/beast/utility/Zero.h # cspell: ignore Ritchford
+fi
+
+# Restore newlines and tabs in string literals in the affected file.
+${SED_COMMAND} -i -E "s@${PLACEHOLDER_NEWLINE}@\\\n@g" src/test/rpc/ValidatorInfo_test.cpp
+${SED_COMMAND} -i -E "s@${PLACEHOLDER_TAB}@\\\t@g" src/test/rpc/ValidatorInfo_test.cpp
+
+popd
+echo "Removal complete."

.github/scripts/rename/definitions.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -e
+
+# On MacOS, ensure that GNU sed is installed and available as `gsed`.
+SED_COMMAND=sed
+if [[ "${OSTYPE}" == 'darwin'* ]]; then
+    if ! command -v gsed &> /dev/null; then
+        echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
+        exit 1
+    fi
+    SED_COMMAND=gsed
+fi
+
+# This script renames definitions, such as include guards, in this project.
+# Specifically, it renames "RIPPLED_XXX" and "RIPPLE_XXX" to "XRPL_XXX" by
+# scanning all cmake, header, and source files in the specified directory and
+# its subdirectories.
+# Usage: .github/scripts/rename/definitions.sh <repository directory>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <repository directory>"
+    exit 1
+fi
+
+DIRECTORY=$1
+echo "Processing directory: ${DIRECTORY}"
+if [ ! -d "${DIRECTORY}" ]; then
+    echo "Error: Directory '${DIRECTORY}' does not exist."
+    exit 1
+fi
+
+find "${DIRECTORY}" -type f \( -name "*.h" -o -name "*.hpp" -o -name "*.ipp" -o -name "*.cpp" \) | while read -r FILE; do
+    echo "Processing file: ${FILE}"
+    ${SED_COMMAND} -i -E 's@#(define|endif|if|ifdef|ifndef)(.*)(RIPPLED_|RIPPLE_)([A-Z0-9_]+)@#\1\2XRPL_\4@g' "${FILE}"
+done
+find "${DIRECTORY}" -type f \( -name "*.cmake" -o -name "*.txt" \) | while read -r FILE; do
+    echo "Processing file: ${FILE}"
+    ${SED_COMMAND} -i -E 's@(RIPPLED_|RIPPLE_)([A-Z0-9_]+)@XRPL_\2@g' "${FILE}"
+done
+echo "Renaming complete."

.github/scripts/rename/docs.sh

@@ -0,0 +1,96 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -e
+
+# On MacOS, ensure that GNU sed is installed and available as `gsed`.
+SED_COMMAND=sed
+if [[ "${OSTYPE}" == 'darwin'* ]]; then
+    if ! command -v gsed &> /dev/null; then
+        echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
+        exit 1
+    fi
+    SED_COMMAND=gsed
+fi
+
+# This script renames all remaining references to `ripple` and `rippled` to
+# `xrpl` and `xrpld`, respectively, in code, comments, and documentation.
+# Usage: .github/scripts/rename/docs.sh <repository directory>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <repository directory>"
+    exit 1
+fi
+
+DIRECTORY=$1
+echo "Processing directory: ${DIRECTORY}"
+if [ ! -d "${DIRECTORY}" ]; then
+    echo "Error: Directory '${DIRECTORY}' does not exist."
+    exit 1
+fi
+pushd "${DIRECTORY}"
+
+find . -type f \( -name "*.h" -o -name "*.hpp" -o -name "*.ipp" -o -name "*.cpp" -o -name "*.txt" -o -name "*.cfg" -o -name "*.md" -o -name "*.proto" \) -not -path "./.github/scripts/*" | while read -r FILE; do
+    echo "Processing file: ${FILE}"
+    ${SED_COMMAND} -i 's/rippleLockEscrowMPT/lockEscrowMPT/g' "${FILE}"
+    ${SED_COMMAND} -i 's/rippleUnlockEscrowMPT/unlockEscrowMPT/g' "${FILE}"
+    ${SED_COMMAND} -i 's/rippleCredit/directSendNoFee/g' "${FILE}"
+    ${SED_COMMAND} -i 's/rippleSend/directSendNoLimit/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's@([^/+-])rippled@\1xrpld@g' "${FILE}"
+    ${SED_COMMAND} -i -E 's@([^/+-])Rippled@\1Xrpld@g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/^rippled/xrpld/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/^Rippled/Xrpld/g' "${FILE}"
+    # cspell: disable
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (a|A)ddress/XRPL address/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (a|A)ccount/XRPL account/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (a|A)lgorithm/XRPL algorithm/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (c|C)lient/XRPL client/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (c|C)luster/XRPL cluster/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (c|C)onsensus/XRPL consensus/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (d|D)efault/XRPL default/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (e|E)poch/XRPL epoch/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (f|F)eature/XRPL feature/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (n|N)etwork/XRPL network/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (p|P)ayment/XRPL payment/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (p|P)rotocol/XRPL protocol/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (r|R)epository/XRPL repository/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple RPC/XRPL RPC/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (s|S)erialization/XRPL serialization/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (s|S)erver/XRPL server/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (s|S)pecific/XRPL specific/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple Source/XRPL Source/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (t|T)imestamp/XRPL timestamp/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple uses the consensus/XRPL uses the consensus/g' "${FILE}"
+    ${SED_COMMAND} -i -E 's/(r|R)ipple (v|V)alidator/XRPL validator/g' "${FILE}"
+    # cspell: enable
+    ${SED_COMMAND} -i 's/RippleLib/XrplLib/g' "${FILE}"
+    ${SED_COMMAND} -i 's/ripple-lib/XrplLib/g' "${FILE}"
+    ${SED_COMMAND} -i 's@opt/ripple/@opt/xrpld/@g' "${FILE}"
+    ${SED_COMMAND} -i 's@src/ripple/@src/xrpld/@g' "${FILE}"
+    ${SED_COMMAND} -i 's@ripple/app/@xrpld/app/@g' "${FILE}"
+    ${SED_COMMAND} -i 's@github.com/ripple/rippled@github.com/XRPLF/rippled@g' "${FILE}"
+    ${SED_COMMAND} -i 's/\ba xrpl/an xrpl/g' "${FILE}"
+    ${SED_COMMAND} -i 's/\ba XRPL/an XRPL/g' "${FILE}"
+done
+${SED_COMMAND} -i 's/ripple_libs/xrpl_libs/' BUILD.md
+${SED_COMMAND} -i 's/Ripple integrators/XRPL developers/' README.md
+${SED_COMMAND} -i 's/sanitizer-configuration-for-rippled/sanitizer-configuration-for-xrpld/' docs/build/sanitizers.md
+${SED_COMMAND} -i 's/rippled/xrpld/g' .github/scripts/levelization/README.md
+${SED_COMMAND} -i 's/rippled/xrpld/g' .github/scripts/strategy-matrix/generate.py
+${SED_COMMAND} -i 's@/rippled@/xrpld@g' docs/build/install.md
+${SED_COMMAND} -i 's@github.com/XRPLF/xrpld@github.com/XRPLF/rippled@g' docs/build/install.md
+${SED_COMMAND} -i 's/rippled/xrpld/g' docs/Doxyfile
+${SED_COMMAND} -i 's/ripple_basics/basics/' include/xrpl/basics/CountedObject.h
+${SED_COMMAND} -i 's/<ripple/<xrpl/' include/xrpl/protocol/AccountID.h
+${SED_COMMAND} -i 's/Ripple:/the XRPL:/g' include/xrpl/protocol/SecretKey.h
+${SED_COMMAND} -i 's/Ripple:/the XRPL:/g' include/xrpl/protocol/Seed.h
+${SED_COMMAND} -i 's/ripple/xrpl/g' src/test/README.md
+${SED_COMMAND} -i 's/www.ripple.com/www.xrpl.org/g' src/test/protocol/Seed_test.cpp
+
+# Restore specific changes.
+${SED_COMMAND} -i 's@b5efcc/src/xrpld@b5efcc/src/ripple@' include/xrpl/protocol/README.md
+${SED_COMMAND} -i 's/dbPrefix_ = "xrpldb"/dbPrefix_ = "rippledb"/' src/xrpld/app/misc/SHAMapStoreImp.h # cspell: disable-line
+${SED_COMMAND} -i 's/kCONFIG_LEGACY_NAME = "xrpld.cfg"/kCONFIG_LEGACY_NAME = "rippled.cfg"/' src/xrpld/core/detail/Config.cpp
+
+popd
+echo "Renaming complete."

.github/scripts/rename/include.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -e
+
+# This script checks whether there are no new include guards introduced by a new
+# PR, as header files should use "#pragma once" instead. The script assumes any
+# include guards will use "XRPL_" as prefix.
+# Usage: .github/scripts/rename/include.sh <repository directory>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <repository directory>"
+    exit 1
+fi
+
+DIRECTORY=$1
+echo "Processing directory: ${DIRECTORY}"
+if [ ! -d "${DIRECTORY}" ]; then
+    echo "Error: Directory '${DIRECTORY}' does not exist."
+    exit 1
+fi
+
+find "${DIRECTORY}" -type f \( -name "*.h" -o -name "*.hpp" -o -name "*.ipp" \) | while read -r FILE; do
+    echo "Processing file: ${FILE}"
+    if grep -q "#ifndef XRPL_" "${FILE}"; then
+        echo "Please replace all include guards by #pragma once."
+        exit 1
+    fi
+done
+echo "Checking complete."

.github/scripts/rename/namespace.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -e
+
+# On MacOS, ensure that GNU sed is installed and available as `gsed`.
+SED_COMMAND=sed
+if [[ "${OSTYPE}" == 'darwin'* ]]; then
+    if ! command -v gsed &> /dev/null; then
+        echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
+        exit 1
+    fi
+    SED_COMMAND=gsed
+fi
+
+# This script renames the `ripple` namespace to `xrpl` in this project.
+# Specifically, it renames all occurrences of `namespace ripple` and `ripple::`
+# to `namespace xrpl` and `xrpl::`, respectively, by scanning all header and
+# source files in the specified directory and its subdirectories, as well as any
+# occurrences in the documentation. It also renames them in the test suites.
+# Usage: .github/scripts/rename/namespace.sh <repository directory>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <repository directory>"
+    exit 1
+fi
+
+DIRECTORY=$1
+echo "Processing directory: ${DIRECTORY}"
+if [ ! -d "${DIRECTORY}" ]; then
+    echo "Error: Directory '${DIRECTORY}' does not exist."
+    exit 1
+fi
+pushd "${DIRECTORY}"
+
+DIRECTORIES=("include" "src" "tests")
+for DIRECTORY in "${DIRECTORIES[@]}"; do
+    echo "Processing directory: ${DIRECTORY}"
+
+    find "${DIRECTORY}" -type f \( -name "*.h" -o -name "*.hpp" -o -name "*.ipp" -o -name "*.cpp" -o -name "*.macro" \) | while read -r FILE; do
+        echo "Processing file: ${FILE}"
+        ${SED_COMMAND} -i 's/namespace ripple/namespace xrpl/g' "${FILE}"
+        ${SED_COMMAND} -i 's/ripple::/xrpl::/g' "${FILE}"
+        ${SED_COMMAND} -i 's/"ripple:/"xrpl::/g' "${FILE}"
+        ${SED_COMMAND} -i -E 's/(BEAST_DEFINE_TESTSUITE.+)ripple(.+)/\1xrpl\2/g' "${FILE}"
+    done
+done
+
+# Special case for NuDBFactory that has ripple twice in the test suite name.
+${SED_COMMAND} -i -E 's/(BEAST_DEFINE_TESTSUITE.+)ripple(.+)/\1xrpl\2/g' src/test/nodestore/NuDBFactory_test.cpp
+
+DIRECTORY=$1
+find "${DIRECTORY}" -type f -name "*.md" | while read -r FILE; do
+    echo "Processing file: ${FILE}"
+    ${SED_COMMAND} -i 's/ripple::/xrpl::/g' "${FILE}"
+done
+
+popd
+echo "Renaming complete."

.github/scripts/strategy-matrix/generate.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+import argparse
+import itertools
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+THIS_DIR = Path(__file__).parent.resolve()
+
+
+@dataclass
+class Config:
+    architecture: list[dict]
+    os: list[dict]
+    build_type: list[str]
+    cmake_args: list[str]
+
+
+"""
+Generate a strategy matrix for GitHub Actions CI.
+
+On each PR commit we will build a selection of Debian, RHEL, Ubuntu, MacOS, and
+Windows configurations, while upon merge into the develop or release branches,
+we will build all configurations, and test most of them.
+
+We will further set additional CMake arguments as follows:
+- All builds will have the `tests`, `werr`, and `xrpld` options.
+- All builds will have the `wextra` option except for GCC 12 and Clang 16.
+- All release builds will have the `assert` option.
+- Certain Debian Bookworm configurations will change the reference fee, enable
+  codecov, and enable voidstar in PRs.
+"""
+
+
+def generate_strategy_matrix(all: bool, config: Config) -> list:
+    configurations = []
+    for architecture, os, build_type, cmake_args in itertools.product(
+        config.architecture, config.os, config.build_type, config.cmake_args
+    ):
+        # The default CMake target is 'all' for Linux and MacOS and 'install'
+        # for Windows, but it can get overridden for certain configurations.
+        cmake_target = "install" if os["distro_name"] == "windows" else "all"
+
+        # We build and test all configurations by default, except for Windows in
+        # Debug, because it is too slow, as well as when code coverage is
+        # enabled as that mode already runs the tests.
+        build_only = False
+        if os["distro_name"] == "windows" and build_type == "Debug":
+            build_only = True
+
+        # Only generate a subset of configurations in PRs.
+        if not all:
+            # Debian:
+            # - Bookworm using GCC 13: Debug on linux/amd64, set the reference
+            #   fee to 500 and enable code coverage (which will be done below).
+            # - Bookworm using GCC 15: Debug on linux/amd64, enable Address and
+            #   UB sanitizers (which will be done below).
+            # - Bookworm using Clang 16: Debug on linux/amd64, enable voidstar.
+            # - Bookworm using Clang 17: Release on linux/amd64, set the
+            #   reference fee to 1000.
+            # - Bookworm using Clang 20: Debug on linux/amd64, enable Address
+            #   and UB sanitizers (which will be done below).
+            if os["distro_name"] == "debian":
+                skip = True
+                if os["distro_version"] == "bookworm":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-13"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        cmake_args = f"-DUNIT_TEST_REFERENCE_FEE=500 {cmake_args}"
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-16"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        cmake_args = f"-Dvoidstar=ON {cmake_args}"
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-17"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        cmake_args = f"-DUNIT_TEST_REFERENCE_FEE=1000 {cmake_args}"
+                        skip = False
+                elif os["distro_version"] == "trixie":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                if skip:
+                    continue
+
+            # RHEL:
+            # - 9 using GCC 12: Debug on linux/amd64.
+            # - 10 using Clang: Release on linux/amd64.
+            if os["distro_name"] == "rhel":
+                skip = True
+                if os["distro_version"] == "9":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                elif os["distro_version"] == "10":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-any"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                if skip:
+                    continue
+
+            # Ubuntu:
+            # - Jammy using GCC 12: Debug on linux/arm64.
+            # - Noble using GCC 14: Release on linux/amd64.
+            # - Noble using Clang 18: Debug on linux/amd64.
+            # - Noble using Clang 19: Release on linux/arm64.
+            if os["distro_name"] == "ubuntu":
+                skip = True
+                if os["distro_version"] == "jammy":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/arm64"
+                    ):
+                        skip = False
+                elif os["distro_version"] == "noble":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-14"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-18"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-19"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/arm64"
+                    ):
+                        skip = False
+                if skip:
+                    continue
+
+            # MacOS:
+            # - Debug on macos/arm64.
+            if os["distro_name"] == "macos" and not (
+                build_type == "Debug" and architecture["platform"] == "macos/arm64"
+            ):
+                continue
+
+            # Windows:
+            # - Release on windows/amd64.
+            if os["distro_name"] == "windows" and not (
+                build_type == "Release" and architecture["platform"] == "windows/amd64"
+            ):
+                continue
+
+        # Additional CMake arguments.
+        cmake_args = f"{cmake_args} -Dtests=ON -Dwerr=ON -Dxrpld=ON"
+        if not f"{os['compiler_name']}-{os['compiler_version']}" in [
+            "gcc-12",
+            "clang-16",
+        ]:
+            cmake_args = f"{cmake_args} -Dwextra=ON"
+        if build_type == "Release":
+            cmake_args = f"{cmake_args} -Dassert=ON"
+
+        # We skip all RHEL on arm64 due to a build failure that needs further
+        # investigation.
+        if os["distro_name"] == "rhel" and architecture["platform"] == "linux/arm64":
+            continue
+
+        # We skip all clang 20+ on arm64 due to Boost build error.
+        if (
+            os["compiler_name"] == "clang"
+            and os["compiler_version"].isdigit()
+            and int(os["compiler_version"]) >= 20
+            and architecture["platform"] == "linux/arm64"
+        ):
+            continue
+
+        # Enable code coverage for Debian Bookworm using GCC 13 in Debug on
+        # linux/amd64.
+        if (
+            f"{os['distro_name']}-{os['distro_version']}" == "debian-bookworm"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-13"
+            and build_type == "Debug"
+            and architecture["platform"] == "linux/amd64"
+        ):
+            cmake_args = f"{cmake_args} -Dcoverage=ON -Dcoverage_format=xml -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_C_FLAGS=-O0 -DCMAKE_CXX_FLAGS=-O0"
+
+        # Enable unity build for Ubuntu Jammy using GCC 12 in Debug on
+        # linux/amd64.
+        if (
+            f"{os['distro_name']}-{os['distro_version']}" == "ubuntu-jammy"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
+            and build_type == "Debug"
+            and architecture["platform"] == "linux/amd64"
+        ):
+            cmake_args = f"{cmake_args} -Dunity=ON"
+
+        # Generate a unique name for the configuration, e.g. macos-arm64-debug
+        # or debian-bookworm-gcc-12-amd64-release.
+        config_name = os["distro_name"]
+        if (n := os["distro_version"]) != "":
+            config_name += f"-{n}"
+        if (n := os["compiler_name"]) != "":
+            config_name += f"-{n}"
+        if (n := os["compiler_version"]) != "":
+            config_name += f"-{n}"
+        config_name += (
+            f"-{architecture['platform'][architecture['platform'].find('/')+1:]}"
+        )
+        config_name += f"-{build_type.lower()}"
+        if "-Dcoverage=ON" in cmake_args:
+            config_name += "-coverage"
+        if "-Dunity=ON" in cmake_args:
+            config_name += "-unity"
+
+        # Add the configuration to the list, with the most unique fields first,
+        # so that they are easier to identify in the GitHub Actions UI, as long
+        # names get truncated.
+        # Add Address and UB sanitizers as separate configurations for specific
+        # bookworm distros. Thread sanitizer is currently disabled (see below).
+        # GCC-Asan xrpld-embedded tests are failing because of https://github.com/google/sanitizers/issues/856
+        if (
+            os["distro_version"] == "bookworm"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15"
+        ) or (
+            os["distro_version"] == "trixie"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22"
+        ):
+            # Add ASAN and UBSAN configurations for both gcc-15 and clang-22
+            configurations.append(
+                {
+                    "config_name": config_name + "-asan",
+                    "cmake_args": cmake_args,
+                    "cmake_target": cmake_target,
+                    "build_only": build_only,
+                    "build_type": build_type,
+                    "os": os,
+                    "architecture": architecture,
+                    "sanitizers": "address",
+                }
+            )
+            configurations.append(
+                {
+                    "config_name": config_name + "-ubsan",
+                    "cmake_args": cmake_args,
+                    "cmake_target": cmake_target,
+                    "build_only": build_only,
+                    "build_type": build_type,
+                    "os": os,
+                    "architecture": architecture,
+                    "sanitizers": "undefinedbehavior",
+                }
+            )
+            # TSAN is deactivated due to seg faults with latest compilers.
+            activate_tsan = False
+            if activate_tsan:
+                configurations.append(
+                    {
+                        "config_name": config_name + "-tsan-ubsan",
+                        "cmake_args": cmake_args,
+                        "cmake_target": cmake_target,
+                        "build_only": build_only,
+                        "build_type": build_type,
+                        "os": os,
+                        "architecture": architecture,
+                        "sanitizers": "thread,undefinedbehavior",
+                    }
+                )
+        else:
+            configurations.append(
+                {
+                    "config_name": config_name,
+                    "cmake_args": cmake_args,
+                    "cmake_target": cmake_target,
+                    "build_only": build_only,
+                    "build_type": build_type,
+                    "os": os,
+                    "architecture": architecture,
+                    "sanitizers": "",
+                }
+            )
+
+    return configurations
+
+
+def read_config(file: Path) -> Config:
+    config = json.loads(file.read_text())
+    if (
+        config["architecture"] is None
+        or config["os"] is None
+        or config["build_type"] is None
+        or config["cmake_args"] is None
+    ):
+        raise Exception("Invalid configuration file.")
+
+    return Config(**config)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-a",
+        "--all",
+        help="Set to generate all configurations (generally used when merging a PR) or leave unset to generate a subset of configurations (generally used when committing to a PR).",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        help="Path to the JSON file containing the strategy matrix configurations.",
+        required=False,
+        type=Path,
+    )
+    args = parser.parse_args()
+
+    matrix = []
+    if args.config is None or args.config == "":
+        matrix += generate_strategy_matrix(
+            args.all, read_config(THIS_DIR / "linux.json")
+        )
+        matrix += generate_strategy_matrix(
+            args.all, read_config(THIS_DIR / "macos.json")
+        )
+        matrix += generate_strategy_matrix(
+            args.all, read_config(THIS_DIR / "windows.json")
+        )
+    else:
+        matrix += generate_strategy_matrix(args.all, read_config(args.config))
+
+    # Generate the strategy matrix.
+    print(f"matrix={json.dumps({'include': matrix})}")

.github/scripts/strategy-matrix/linux.json

@@ -0,0 +1,219 @@
+{
+  "architecture": [
+    {
+      "platform": "linux/amd64",
+      "runner": ["self-hosted", "Linux", "X64", "heavy"]
+    },
+    {
+      "platform": "linux/arm64",
+      "runner": ["self-hosted", "Linux", "ARM64", "heavy-arm64"]
+    }
+  ],
+  "os": [
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "gcc",
+      "compiler_version": "12",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "gcc",
+      "compiler_version": "13",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "gcc",
+      "compiler_version": "15",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "16",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "17",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "18",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "19",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "20",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "gcc",
+      "compiler_version": "15",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "clang",
+      "compiler_version": "20",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "clang",
+      "compiler_version": "21",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "clang",
+      "compiler_version": "22",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "8",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "8",
+      "compiler_name": "clang",
+      "compiler_version": "any",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "9",
+      "compiler_name": "gcc",
+      "compiler_version": "12",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "9",
+      "compiler_name": "gcc",
+      "compiler_version": "13",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "9",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "9",
+      "compiler_name": "clang",
+      "compiler_version": "any",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "10",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "10",
+      "compiler_name": "clang",
+      "compiler_version": "any",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "jammy",
+      "compiler_name": "gcc",
+      "compiler_version": "12",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "gcc",
+      "compiler_version": "13",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "clang",
+      "compiler_version": "16",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "clang",
+      "compiler_version": "17",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "clang",
+      "compiler_version": "18",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "clang",
+      "compiler_version": "19",
+      "image_sha": "4c086b9"
+    }
+  ],
+  "build_type": ["Debug", "Release"],
+  "cmake_args": [""]
+}

.github/scripts/strategy-matrix/macos.json

@@ -0,0 +1,19 @@
+{
+  "architecture": [
+    {
+      "platform": "macos/arm64",
+      "runner": ["self-hosted", "macOS", "ARM64", "mac-runner-m1"]
+    }
+  ],
+  "os": [
+    {
+      "distro_name": "macos",
+      "distro_version": "",
+      "compiler_name": "",
+      "compiler_version": "",
+      "image_sha": ""
+    }
+  ],
+  "build_type": ["Debug", "Release"],
+  "cmake_args": ["-DCMAKE_POLICY_VERSION_MINIMUM=3.5"]
+}

.github/scripts/strategy-matrix/windows.json

@@ -0,0 +1,19 @@
+{
+  "architecture": [
+    {
+      "platform": "windows/amd64",
+      "runner": ["self-hosted", "Windows", "devbox"]
+    }
+  ],
+  "os": [
+    {
+      "distro_name": "windows",
+      "distro_version": "",
+      "compiler_name": "",
+      "compiler_version": "",
+      "image_sha": ""
+    }
+  ],
+  "build_type": ["Debug", "Release"],
+  "cmake_args": [""]
+}

.github/workflows/build-nix-image.yml

@@ -0,0 +1,101 @@
+name: Build Nix Docker image
+
+on:
+  push:
+    branches:
+      - develop
+    paths:
+      - ".github/workflows/build-nix-image.yml"
+      - "docker/nix.Dockerfile"
+      - "flake.nix"
+      - "flake.lock"
+      - "nix/**"
+  pull_request:
+    paths:
+      - ".github/workflows/build-nix-image.yml"
+      - "docker/nix.Dockerfile"
+      - "flake.nix"
+      - "flake.lock"
+      - "nix/**"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  UBUNTU_VERSION: "20.04"
+  RHEL_VERSION: "9"
+  DEBIAN_VERSION: "bookworm"
+
+jobs:
+  build:
+    name: Build and push Nix image (${{ matrix.distro }})
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        include:
+          - distro: nixos
+          - distro: ubuntu
+          - distro: rhel
+          - distro: debian
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Determine base image
+        id: vars
+        run: |
+          case "${{ matrix.distro }}" in
+            nixos)
+              echo "base_image=nixos/nix:latest" >> $GITHUB_OUTPUT
+              ;;
+            ubuntu)
+              echo "base_image=ubuntu:${UBUNTU_VERSION}" >> $GITHUB_OUTPUT
+              ;;
+            rhel)
+              echo "base_image=registry.access.redhat.com/ubi${RHEL_VERSION}/ubi:latest" >> $GITHUB_OUTPUT
+              ;;
+            debian)
+              echo "base_image=debian:${DEBIAN_VERSION}" >> $GITHUB_OUTPUT
+              ;;
+          esac
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
+
+      - name: Login to GitHub Container Registry
+        if: github.event_name == 'push'
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Docker metadata
+        id: meta
+        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
+        with:
+          images: ghcr.io/xrplf/ci/nix-${{ matrix.distro }}
+          tags: |
+            type=sha,prefix=sha-,format=short
+            type=raw,value=latest
+
+      - name: Build and push
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: .
+          file: docker/nix.Dockerfile
+          platforms: linux/amd64
+          push: ${{ github.event_name == 'push' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          build-args: BASE_IMAGE=${{ steps.vars.outputs.base_image }}

.github/workflows/check-pr-commits.yml

@@ -0,0 +1,13 @@
+name: Check PR commits
+
+on:
+  pull_request_target:
+
+# The action needs to have write permissions to post comments on the PR.
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  check_commits:
+    uses: XRPLF/actions/.github/workflows/check-pr-commits.yml@e2c7f400d1e85ae65dad552fd425169fbacca4a3

.github/workflows/check-pr-description.yml

@@ -0,0 +1,30 @@
+name: Check PR description
+
+on:
+  merge_group:
+    types:
+      - checks_requested
+  pull_request:
+    types: [opened, edited, reopened, synchronize, ready_for_review]
+    branches: [develop]
+
+jobs:
+  check_description:
+    if: ${{ github.event.pull_request.draft != true }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Write PR body to file
+        env:
+          PR_BODY: ${{ github.event.pull_request.body }}
+        if: ${{ github.event_name == 'pull_request' }}
+        run: printenv PR_BODY > pr_body.md
+
+      - name: Check PR description differs from template
+        if: ${{ github.event_name == 'pull_request' }}
+        run: >
+          python .github/scripts/check-pr-description.py
+          --template-file .github/pull_request_template.md
+          --pr-body-file pr_body.md

.github/workflows/check-pr-title.yml

@@ -0,0 +1,14 @@
+name: Check PR title
+
+on:
+  merge_group:
+    types:
+      - checks_requested
+  pull_request:
+    types: [opened, edited, reopened, synchronize, ready_for_review]
+    branches: [develop]
+
+jobs:
+  check_title:
+    if: ${{ github.event.pull_request.draft != true }}
+    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@a5d8dd35be543365e90a11358447130c8763871d

.github/workflows/conflicting-pr.yml

@@ -0,0 +1,25 @@
+name: Label PRs with merge conflicts
+
+on:
+  # So that PRs touching the same files as the push are updated.
+  push:
+  # So that the `dirtyLabel` is removed if conflicts are resolved.
+  # We recommend `pull_request_target` so that github secrets are available.
+  # In `pull_request` we wouldn't be able to change labels of fork PRs.
+  pull_request_target:
+    types: [synchronize]
+
+permissions:
+  pull-requests: write
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if PRs are dirty
+        uses: eps1lon/actions-label-merge-conflict@1df065ebe6e3310545d4f4c4e862e43bdca146f0 # v3.0.3
+        with:
+          dirtyLabel: "PR: has conflicts"
+          repoToken: "${{ secrets.GITHUB_TOKEN }}"
+          commentOnDirty: "This PR has conflicts, please resolve them in order for the PR to be reviewed."
+          commentOnClean: "All conflicts have been resolved. Assigned reviewers can now start or resume their review."

.github/workflows/doc-review.yml

@@ -0,0 +1,90 @@
+name: Documentation Review
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+    paths:
+      - 'include/**/*.h'
+      - 'src/libxrpl/**/*.h'
+      - 'src/libxrpl/**/*.cpp'
+      - 'src/xrpld/**/*.h'
+      - 'src/xrpld/**/*.cpp'
+
+concurrency:
+  group: doc-review-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  review:
+    if: github.head_ref != 'dangell7/docs' && github.head_ref != 'dangell7/docs-full'
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+      contents: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Set up Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: '20'
+          cache: 'npm'
+          cache-dependency-path: .github/scripts/doc-agent/package-lock.json
+
+      - name: Install doc-agent dependencies
+        working-directory: .github/scripts/doc-agent
+        run: npm ci
+
+      - name: Run documentation review
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: |
+          cd .github/scripts/doc-agent
+          npm run review -- "${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }}"
+
+      - name: Post review summary
+        if: always()
+        uses: marocchino/sticky-pull-request-comment@67d0dec7b07ed060a405f9b2a64b8ab319fdd7db # v2.9.2
+        with:
+          header: doc-review
+          path: .github/scripts/doc-agent/doc-review-report.md
+
+      - name: Post inline review comments
+        if: always()
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          script: |
+            const fs = require('fs');
+            const path = '.github/scripts/doc-agent/doc-review-comments.json';
+            if (!fs.existsSync(path)) return;
+
+            const comments = JSON.parse(fs.readFileSync(path, 'utf8'));
+            if (comments.length === 0) return;
+
+            const pull_number = context.payload.pull_request.number;
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+
+            for (const comment of comments) {
+              try {
+                await github.rest.pulls.createReviewComment({
+                  owner,
+                  repo,
+                  pull_number,
+                  body: comment.body,
+                  commit_id: '${{ github.event.pull_request.head.sha }}',
+                  path: comment.path,
+                  line: comment.line,
+                  side: 'RIGHT',
+                });
+              } catch (e) {
+                console.log(`Failed to post comment on ${comment.path}:${comment.line}: ${e.message}`);
+              }
+            }

.github/workflows/on-pr.yml

@@ -0,0 +1,176 @@
+# This workflow runs all workflows to check, build and test the project on
+# various Linux flavors, as well as on MacOS and Windows, on every push to a
+# user branch. However, it will not run if the pull request is a draft unless it
+# has the 'DraftRunCI' label. For commits to PRs that target a release branch,
+# it also uploads the libxrpl recipe to the Conan remote.
+name: PR
+
+on:
+  merge_group:
+    types:
+      - checks_requested
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  # This job determines whether the rest of the workflow should run. It runs
+  # when the PR is not a draft (which should also cover merge-group) or
+  # has the 'DraftRunCI' label.
+  should-run:
+    if: ${{ !github.event.pull_request.draft || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Determine changed files
+        # This step checks whether any files have changed that should
+        # cause the next jobs to run. We do it this way rather than
+        # using `paths` in the `on:` section, because all required
+        # checks must pass, even for changes that do not modify anything
+        # that affects those checks. We would therefore like to make the
+        # checks required only if the job runs, but GitHub does not
+        # support that directly. By always executing the workflow on new
+        # commits and by using the changed-files action below, we ensure
+        # that Github considers any skipped jobs to have passed, and in
+        # turn the required checks as well.
+        id: changes
+        uses: tj-actions/changed-files@9426d40962ed5378910ee2e21d5f8c6fcbf2dd96 # v47.0.6
+        with:
+          files: |
+            # These paths are unique to `on-pr.yml`.
+            .github/scripts/levelization/**
+            .github/scripts/rename/**
+            .github/workflows/reusable-check-levelization.yml
+            .github/workflows/reusable-check-rename.yml
+            .github/workflows/on-pr.yml
+
+            # Keep the paths below in sync with those in `on-trigger.yml`.
+            .github/actions/build-deps/**
+            .github/actions/generate-version/**
+            .github/actions/setup-conan/**
+            .github/scripts/strategy-matrix/**
+            .github/workflows/reusable-build-test-config.yml
+            .github/workflows/reusable-build-test.yml
+            .github/workflows/reusable-clang-tidy.yml
+            .github/workflows/reusable-strategy-matrix.yml
+            .github/workflows/reusable-test.yml
+            .github/workflows/reusable-upload-recipe.yml
+            .clang-tidy
+            .codecov.yml
+            cmake/**
+            conan/**
+            external/**
+            include/**
+            src/**
+            tests/**
+            CMakeLists.txt
+            conanfile.py
+            conan.lock
+      - name: Check whether to run
+        # This step determines whether the rest of the workflow should
+        # run. The rest of the workflow will run if this job runs AND at
+        # least one of:
+        # * Any of the files checked in the `changes` step were modified
+        # * The PR is NOT a draft and is labeled "Ready to merge"
+        # * The workflow is running from the merge queue
+        id: go
+        env:
+          FILES: ${{ steps.changes.outputs.any_changed }}
+          DRAFT: ${{ github.event.pull_request.draft }}
+          READY: ${{ contains(github.event.pull_request.labels.*.name, 'Ready to merge') }}
+          MERGE: ${{ github.event_name == 'merge_group' }}
+        run: |
+          echo "go=${{ (env.DRAFT != 'true' && env.READY == 'true') || env.FILES == 'true' || env.MERGE == 'true' }}" >> "${GITHUB_OUTPUT}"
+          cat "${GITHUB_OUTPUT}"
+    outputs:
+      go: ${{ steps.go.outputs.go == 'true' }}
+
+  check-levelization:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-check-levelization.yml
+
+  check-rename:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-check-rename.yml
+
+  clang-tidy:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-clang-tidy.yml
+    permissions:
+      issues: write
+      contents: read
+    with:
+      check_only_changed: true
+      create_issue_on_failure: false
+
+  build-test:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-build-test.yml
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [linux, macos, windows]
+    with:
+      # Enable ccache only for events targeting the XRPLF repository, since
+      # other accounts will not have access to our remote cache storage.
+      ccache_enabled: ${{ github.repository_owner == 'XRPLF' }}
+      os: ${{ matrix.os }}
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  upload-recipe:
+    needs:
+      - should-run
+      - build-test
+    # Only run when committing to a PR that targets a release branch.
+    if: ${{ github.repository == 'XRPLF/rippled' && needs.should-run.outputs.go == 'true' && github.event_name == 'pull_request' && startsWith(github.event.pull_request.base.ref, 'release') }}
+    uses: ./.github/workflows/reusable-upload-recipe.yml
+    secrets:
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}
+
+  notify-clio:
+    needs: upload-recipe
+    runs-on: ubuntu-latest
+    steps:
+      # Notify the Clio repository about the newly proposed release version, so
+      # it can be checked for compatibility before the release is actually made.
+      - name: Notify Clio
+        env:
+          GH_TOKEN: ${{ secrets.CLIO_NOTIFY_TOKEN }}
+          PR_URL: ${{ github.event.pull_request.html_url }}
+        run: |
+          gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
+          /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
+          -F "client_payload[ref]=${{ needs.upload-recipe.outputs.recipe_ref }}" \
+          -F "client_payload[pr_url]=${PR_URL}"
+
+  passed:
+    if: failure() || cancelled()
+    needs:
+      - check-levelization
+      - check-rename
+      - clang-tidy
+      - build-test
+      - upload-recipe
+      - notify-clio
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fail
+        run: exit 1

.github/workflows/on-tag.yml

@@ -0,0 +1,24 @@
+# This workflow uploads the libxrpl recipe to the Conan remote when a versioned
+# tag is pushed.
+name: Tag
+
+on:
+  push:
+    tags:
+      - "[0-9]+.[0-9]+.[0-9]*"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  upload-recipe:
+    if: ${{ github.repository == 'XRPLF/rippled' }}
+    uses: ./.github/workflows/reusable-upload-recipe.yml
+    secrets:
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}

.github/workflows/on-trigger.yml

@@ -0,0 +1,97 @@
+# This workflow runs all workflows to build and test the code on various Linux
+# flavors, as well as on MacOS and Windows, on a scheduled basis, on merge into
+# the 'develop' or 'release*' branches, or when requested manually. Upon pushes
+# to the develop branch it also uploads the libxrpl recipe to the Conan remote.
+name: Trigger
+
+on:
+  push:
+    branches:
+      - "develop"
+      - "release*"
+    paths:
+      # These paths are unique to `on-trigger.yml`.
+      - ".github/workflows/on-trigger.yml"
+
+      # Keep the paths below in sync with those in `on-pr.yml`.
+      - ".github/actions/build-deps/**"
+      - ".github/actions/generate-version/**"
+      - ".github/actions/setup-conan/**"
+      - ".github/scripts/strategy-matrix/**"
+      - ".github/workflows/reusable-build-test-config.yml"
+      - ".github/workflows/reusable-build-test.yml"
+      - ".github/workflows/reusable-clang-tidy.yml"
+      - ".github/workflows/reusable-strategy-matrix.yml"
+      - ".github/workflows/reusable-test.yml"
+      - ".github/workflows/reusable-upload-recipe.yml"
+      - ".clang-tidy"
+      - ".codecov.yml"
+      - "cmake/**"
+      - "conan/**"
+      - "external/**"
+      - "include/**"
+      - "src/**"
+      - "tests/**"
+      - "CMakeLists.txt"
+      - "conanfile.py"
+      - "conan.lock"
+
+  # Run at 06:32 UTC on every day of the week from Monday through Friday. This
+  # will force all dependencies to be rebuilt, which is useful to verify that
+  # all dependencies can be built successfully. Only the dependencies that
+  # are actually missing from the remote will be uploaded.
+  schedule:
+    - cron: "32 6 * * 1-5"
+
+  # Run when manually triggered via the GitHub UI or API.
+  workflow_dispatch:
+
+concurrency:
+  # When a PR is merged into the develop branch it will be assigned a unique
+  # group identifier, so execution will continue even if another PR is merged
+  # while it is still running. In all other cases the group identifier is shared
+  # per branch, so that any in-progress runs are cancelled when a new commit is
+  # pushed.
+  group: ${{ github.workflow }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' && github.sha || github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  clang-tidy:
+    uses: ./.github/workflows/reusable-clang-tidy.yml
+    permissions:
+      issues: write
+      contents: read
+    with:
+      check_only_changed: false
+      create_issue_on_failure: ${{ github.event_name == 'schedule' }}
+
+  build-test:
+    uses: ./.github/workflows/reusable-build-test.yml
+    strategy:
+      fail-fast: ${{ github.event_name == 'merge_group' }}
+      matrix:
+        os: [linux, macos, windows]
+    with:
+      # Enable ccache only for events targeting the XRPLF repository, since
+      # other accounts will not have access to our remote cache storage.
+      # However, we do not enable ccache for events targeting a release branch,
+      # to protect against the rare case that the output produced by ccache is
+      # not identical to a regular compilation.
+      ccache_enabled: ${{ github.repository_owner == 'XRPLF' && !startsWith(github.ref, 'refs/heads/release') }}
+      os: ${{ matrix.os }}
+      strategy_matrix: ${{ github.event_name == 'schedule' && 'all' || 'minimal' }}
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  upload-recipe:
+    needs: build-test
+    # Only run when pushing to the develop branch.
+    if: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
+    uses: ./.github/workflows/reusable-upload-recipe.yml
+    secrets:
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}

.github/workflows/pre-commit.yml

@@ -0,0 +1,20 @@
+name: Run pre-commit hooks
+
+on:
+  merge_group:
+    types:
+      - checks_requested
+  pull_request:
+  push:
+    branches:
+      - "develop"
+      - "release*"
+  workflow_dispatch:
+
+jobs:
+  # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
+  run-hooks:
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@5e942d61bf32f7557a7c159cfac4712a687b3e3a
+    with:
+      runs_on: ubuntu-latest
+      container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'

.github/workflows/publish-docs.yml

@@ -0,0 +1,201 @@
+# Builds Doxygen XML + HTML in a single pass, runs documentation coverage
+# checks on pull requests, and publishes the HTML to GitHub Pages when changes
+# land on `develop`.
+name: Documentation (build, coverage, publish)
+
+on:
+  push:
+    branches:
+      - "develop"
+    paths:
+      - ".github/workflows/publish-docs.yml"
+      - ".github/doc-coverage-thresholds.json"
+      - ".github/scripts/doc-coverage-check.py"
+      - "*.md"
+      - "**/*.md"
+      - "docs/**"
+      - "include/**"
+      - "src/libxrpl/**"
+      - "src/xrpld/**"
+  pull_request:
+    paths:
+      - ".github/workflows/publish-docs.yml"
+      - ".github/doc-coverage-thresholds.json"
+      - ".github/scripts/doc-coverage-check.py"
+      - "*.md"
+      - "**/*.md"
+      - "docs/**"
+      - "include/**"
+      - "src/libxrpl/**"
+      - "src/xrpld/**"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  BUILD_DIR: build
+  # ubuntu-latest has only 2 CPUs for private repositories
+  # https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for--private-repositories
+  NPROC_SUBTRACT: ${{ github.event.repository.visibility == 'public' && '2' || '1' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container: ghcr.io/xrplf/ci/tools-rippled-documentation:sha-a8c7be1
+    permissions:
+      pull-requests: write
+      contents: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
+        with:
+          enable_ccache: false
+
+      - name: Get number of processors
+        uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
+        id: nproc
+        with:
+          subtract: ${{ env.NPROC_SUBTRACT }}
+
+      - name: Install coverxygen
+        # TODO: drop pin once upstream fixes the 1.8.x regression.
+        # 1.8.2 crashes on enums when no --exclude is configured:
+        #   AttributeError: 'str' object has no attribute 'iter'
+        #   at coverxygen/__init__.py extract_enum_qualified_name
+        run: pip install 'coverxygen<1.8'
+
+      - name: Check configuration
+        run: |
+          echo 'Checking path.'
+          echo ${PATH} | tr ':' '\n'
+
+          echo 'Checking CMake version.'
+          cmake --version
+
+          echo 'Checking Doxygen version.'
+          doxygen --version
+
+      - name: Build documentation (PR/HEAD)
+        env:
+          BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
+        run: |
+          mkdir -p "${BUILD_DIR}"
+          cd "${BUILD_DIR}"
+          cmake -Donly_docs=ON ..
+          cmake --build . --target docs --parallel ${BUILD_NPROC}
+
+      - name: Determine changed C++ files
+        if: github.event_name == 'pull_request'
+        id: changed
+        uses: tj-actions/changed-files@9426d40962ed5378910ee2e21d5f8c6fcbf2dd96 # v47.0.6
+        with:
+          files: |
+            include/**/*.h
+            src/**/*.h
+            src/**/*.cpp
+
+      - name: Cache base-branch Doxygen XML
+        if: github.event_name == 'pull_request'
+        id: base-cache
+        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: build-base/docs/xml
+          key: doxygen-xml-${{ github.event.pull_request.base.sha }}-${{ hashFiles('docs/Doxyfile') }}
+
+      - name: Build base-branch Doxygen XML (cache miss)
+        if: github.event_name == 'pull_request' && steps.base-cache.outputs.cache-hit != 'true'
+        env:
+          BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
+        run: |
+          git checkout ${{ github.event.pull_request.base.sha }}
+          mkdir -p build-base
+          cd build-base
+          if ! cmake -Donly_docs=ON .. > cmake.log 2>&1; then
+            echo "::warning::Base-branch cmake configure failed; ratchet disabled for this PR"
+            cat cmake.log
+          elif ! cmake --build . --target docs --parallel ${BUILD_NPROC} > build.log 2>&1; then
+            echo "::warning::Base-branch Doxygen build failed; ratchet disabled for this PR"
+            tail -50 build.log
+          fi
+          cd ..
+          git checkout ${{ github.event.pull_request.head.sha }}
+
+      - name: Generate coverage report (PR)
+        if: github.event_name == 'pull_request'
+        run: |
+          python3 -m coverxygen \
+            --xml-dir ${BUILD_DIR}/docs/xml \
+            --src-dir . \
+            --output doc-coverage.info \
+            --kind class,struct,function,enum,typedef,variable \
+            --scope public
+
+      - name: Generate coverage report (base)
+        if: github.event_name == 'pull_request'
+        run: |
+          if [ -d "build-base/docs/xml" ]; then
+            python3 -m coverxygen \
+              --xml-dir build-base/docs/xml \
+              --src-dir . \
+              --output base-doc-coverage.info \
+              --kind class,struct,function,enum,typedef,variable \
+              --scope public || true
+          fi
+
+      - name: Check coverage thresholds
+        if: github.event_name == 'pull_request'
+        run: |
+          BASE_FLAG=""
+          if [ -f "base-doc-coverage.info" ]; then
+            BASE_FLAG="--base-lcov-file base-doc-coverage.info"
+          fi
+
+          NEW_FILES=""
+          if [ -n "${{ steps.changed.outputs.added_files }}" ]; then
+            NEW_FILES="--new-files ${{ steps.changed.outputs.added_files }}"
+          fi
+
+          python3 .github/scripts/doc-coverage-check.py \
+            --lcov-file doc-coverage.info \
+            --threshold-file .github/doc-coverage-thresholds.json \
+            --output doc-coverage-report.md \
+            ${BASE_FLAG} \
+            ${NEW_FILES} || true
+
+      - name: Post coverage report to PR
+        if: github.event_name == 'pull_request' && always()
+        uses: marocchino/sticky-pull-request-comment@67d0dec7b07ed060a405f9b2a64b8ab319fdd7db # v2.9.2
+        with:
+          header: doc-coverage
+          path: doc-coverage-report.md
+
+      - name: Create documentation artifact
+        if: ${{ github.event.repository.visibility == 'public' && github.event_name == 'push' }}
+        uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
+        with:
+          path: ${{ env.BUILD_DIR }}/docs/html
+
+  deploy:
+    if: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' }}
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deploy
+        uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0

.github/workflows/reusable-build-test-config.yml

@@ -0,0 +1,335 @@
+name: Build and test configuration
+
+on:
+  workflow_call:
+    inputs:
+      build_only:
+        description: 'Whether to only build or to build and test the code ("true", "false").'
+        required: true
+        type: boolean
+
+      build_type:
+        description: 'The build type to use ("Debug", "Release").'
+        required: true
+        type: string
+
+      ccache_enabled:
+        description: "Whether to enable ccache."
+        required: false
+        type: boolean
+        default: false
+
+      cmake_args:
+        description: "Additional arguments to pass to CMake."
+        required: false
+        type: string
+        default: ""
+
+      cmake_target:
+        description: "The CMake target to build."
+        required: true
+        type: string
+
+      runs_on:
+        description: Runner to run the job on as a JSON string
+        required: true
+        type: string
+
+      image:
+        description: "The image to run in (leave empty to run natively)"
+        required: true
+        type: string
+
+      config_name:
+        description: "The configuration string (used for naming artifacts and such)."
+        required: true
+        type: string
+
+      nproc_subtract:
+        description: "The number of processors to subtract when calculating parallelism."
+        required: false
+        type: number
+        default: 2
+
+      sanitizers:
+        description: "The sanitizers to enable."
+        required: false
+        type: string
+        default: ""
+
+    secrets:
+      CODECOV_TOKEN:
+        description: "The Codecov token to use for uploading coverage reports."
+        required: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  # Conan installs the generators in the build/generators directory, see the
+  # layout() method in conanfile.py. We then run CMake from the build directory.
+  BUILD_DIR: build
+
+jobs:
+  build-and-test:
+    name: ${{ inputs.config_name }}
+    runs-on: ${{ fromJSON(inputs.runs_on) }}
+    container: ${{ inputs.image != '' && inputs.image || null }}
+    timeout-minutes: ${{ inputs.sanitizers != '' && 360 || 60 }}
+    env:
+      # Use a namespace to keep the objects separate for each configuration.
+      CCACHE_NAMESPACE: ${{ inputs.config_name }}
+      # Ccache supports both Redis and HTTP endpoints.
+      # * For Redis, use the following format: redis://ip:port, see
+      #   https://github.com/ccache/ccache/wiki/Redis-storage. Note that TLS is
+      #   not directly supported by ccache, and requires use of a proxy.
+      # * For HTTP use the following format: http://ip:port/cache when using
+      #   nginx as backend or http://ip:port|layout=bazel when using Bazel
+      #   Remote Cache, see https://github.com/ccache/ccache/wiki/HTTP-storage.
+      #   Note that HTTPS is not directly supported by ccache.
+      CCACHE_REMOTE_ONLY: true
+      CCACHE_REMOTE_STORAGE: http://cache.dev.ripplex.io:8080|layout=bazel
+      # Ignore the creation and modification timestamps on files, since the
+      # header files are copied into separate directories by CMake, which will
+      # otherwise result in cache misses.
+      CCACHE_SLOPPINESS: include_file_ctime,include_file_mtime
+      # Determine if coverage and voidstar should be enabled.
+      COVERAGE_ENABLED: ${{ contains(inputs.cmake_args, '-Dcoverage=ON') }}
+      VOIDSTAR_ENABLED: ${{ contains(inputs.cmake_args, '-Dvoidstar=ON') }}
+      SANITIZERS_ENABLED: ${{ inputs.sanitizers != '' }}
+    steps:
+      - name: Cleanup workspace (macOS and Windows)
+        if: ${{ runner.os == 'macOS' || runner.os == 'Windows' }}
+        uses: XRPLF/actions/cleanup-workspace@c7d9ce5ebb03c752a354889ecd870cadfc2b1cd4
+
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
+        with:
+          enable_ccache: ${{ inputs.ccache_enabled }}
+
+      - name: Set ccache log file
+        if: ${{ inputs.ccache_enabled && runner.debug == '1' }}
+        run: echo "CCACHE_LOGFILE=${{ runner.temp }}/ccache.log" >> "${GITHUB_ENV}"
+
+      - name: Print build environment
+        uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574
+
+      - name: Get number of processors
+        uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
+        id: nproc
+        with:
+          subtract: ${{ inputs.nproc_subtract }}
+
+      - name: Setup Conan
+        env:
+          SANITIZERS: ${{ inputs.sanitizers }}
+        uses: ./.github/actions/setup-conan
+
+      - name: Build dependencies
+        uses: ./.github/actions/build-deps
+        with:
+          build_nproc: ${{ steps.nproc.outputs.nproc }}
+          build_type: ${{ inputs.build_type }}
+          # Set the verbosity to "quiet" for Windows to avoid an excessive
+          # amount of logs. For other OSes, the "verbose" logs are more useful.
+          log_verbosity: ${{ runner.os == 'Windows' && 'quiet' || 'verbose' }}
+          sanitizers: ${{ inputs.sanitizers }}
+
+      - name: Configure CMake
+        working-directory: ${{ env.BUILD_DIR }}
+        env:
+          BUILD_TYPE: ${{ inputs.build_type }}
+          CMAKE_ARGS: ${{ inputs.cmake_args }}
+        run: |
+          cmake \
+            -G '${{ runner.os == 'Windows' && 'Visual Studio 17 2022' || 'Ninja' }}' \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+            ${CMAKE_ARGS} \
+            ..
+
+      - name: Check protocol autogen files are up-to-date
+        working-directory: ${{ env.BUILD_DIR }}
+        env:
+          MESSAGE: |
+
+            The generated protocol wrapper classes are out of date.
+
+            This typically happens when the macro files or generator scripts
+            have changed but the generated files were not regenerated.
+
+            To fix this:
+              1. Run: cmake --build . --target setup_code_gen
+              2. Run: cmake --build . --target code_gen
+              3. Commit and push the regenerated files
+        run: |
+          set -e
+          cmake --build . --target setup_code_gen
+          cmake --build . --target code_gen
+          DIFF=$(git -C .. status --porcelain -- include/xrpl/protocol_autogen src/tests/libxrpl/protocol_autogen)
+          if [ -n "${DIFF}" ]; then
+            echo "::error::Generated protocol files are out of date"
+            git -C .. diff -- include/xrpl/protocol_autogen src/tests/libxrpl/protocol_autogen
+            echo "${MESSAGE}"
+            exit 1
+          fi
+
+      - name: Build the binary
+        working-directory: ${{ env.BUILD_DIR }}
+        env:
+          BUILD_NPROC: ${{ runner.os == 'Linux' && '16' || steps.nproc.outputs.nproc }}
+          BUILD_TYPE: ${{ inputs.build_type }}
+          CMAKE_TARGET: ${{ inputs.cmake_target }}
+        run: |
+          cmake \
+            --build . \
+            --config "${BUILD_TYPE}" \
+            --parallel "${BUILD_NPROC}" \
+            --target "${CMAKE_TARGET}"
+
+      - name: Show ccache statistics
+        if: ${{ inputs.ccache_enabled }}
+        run: |
+          ccache --show-stats -vv
+          if [ '${{ runner.debug }}' = '1' ]; then
+            cat "${CCACHE_LOGFILE}"
+            curl ${CCACHE_REMOTE_STORAGE%|*}/status || true
+          fi
+
+      - name: Upload the binary (Linux)
+        if: ${{ github.event.repository.visibility == 'public' && runner.os == 'Linux' }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: xrpld-${{ inputs.config_name }}
+          path: ${{ env.BUILD_DIR }}/xrpld
+          retention-days: 3
+          if-no-files-found: error
+
+      - name: Export server definitions
+        if: ${{ runner.os != 'Windows' && !inputs.build_only && env.VOIDSTAR_ENABLED != 'true' }}
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          set -o pipefail
+          ./xrpld --definitions | python3 -m json.tool > server_definitions.json
+
+      - name: Upload server definitions
+        if: ${{ github.event.repository.visibility == 'public' && inputs.config_name == 'debian-bookworm-gcc-13-amd64-release' }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: server-definitions
+          path: ${{ env.BUILD_DIR }}/server_definitions.json
+          retention-days: 3
+          if-no-files-found: error
+
+      - name: Check linking (Linux)
+        if: ${{ runner.os == 'Linux' && env.SANITIZERS_ENABLED == 'false' }}
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          ldd ./xrpld
+          if [ "$(ldd ./xrpld | grep -E '(libstdc\+\+|libgcc)' | wc -l)" -eq 0 ]; then
+            echo 'The binary is statically linked.'
+          else
+            echo 'The binary is dynamically linked.'
+            exit 1
+          fi
+
+      - name: Verify presence of instrumentation (Linux)
+        if: ${{ runner.os == 'Linux' && env.VOIDSTAR_ENABLED == 'true' }}
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          ./xrpld --version | grep libvoidstar
+
+      - name: Set sanitizer options
+        if: ${{ !inputs.build_only && env.SANITIZERS_ENABLED == 'true' }}
+        env:
+          CONFIG_NAME: ${{ inputs.config_name }}
+        run: |
+          ASAN_OPTS="include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-asan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp"
+          if [[ "${CONFIG_NAME}" == *gcc* ]]; then
+            ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
+          fi
+          echo "ASAN_OPTIONS=${ASAN_OPTS}" >> ${GITHUB_ENV}
+          echo "TSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-tsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >> ${GITHUB_ENV}
+          echo "UBSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >> ${GITHUB_ENV}
+          echo "LSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-lsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >> ${GITHUB_ENV}
+
+      - name: Run the separate tests
+        if: ${{ !inputs.build_only }}
+        working-directory: ${{ env.BUILD_DIR }}
+        # Windows locks some of the build files while running tests, and parallel jobs can collide
+        env:
+          BUILD_TYPE: ${{ inputs.build_type }}
+          PARALLELISM: ${{ runner.os == 'Windows' && '1' || steps.nproc.outputs.nproc }}
+        run: |
+          ctest \
+            --output-on-failure \
+            -C "${BUILD_TYPE}" \
+            -j "${PARALLELISM}"
+
+      - name: Run the embedded tests
+        if: ${{ !inputs.build_only }}
+        working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
+        env:
+          BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
+        run: |
+          set -o pipefail
+          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
+          [ "$COVERAGE_ENABLED" = "true" ] && BUILD_NPROC=$(( BUILD_NPROC - 2 ))
+          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee unittest.log
+
+      - name: Show test failure summary
+        if: ${{ failure() && !inputs.build_only }}
+        env:
+          WORKING_DIR: ${{ runner.os == 'Windows' && format('{0}\{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
+        run: |
+          if [ ! -d "${WORKING_DIR}" ]; then
+            echo "Working directory '${WORKING_DIR}' does not exist."
+            exit 0
+          fi
+
+          cd "${WORKING_DIR}"
+
+          if [ ! -f unittest.log ]; then
+            echo "unittest.log not found; embedded tests may not have run."
+            exit 0
+          fi
+
+          if ! grep -E "failed" unittest.log; then
+            echo "Log present but no failure lines found in unittest.log."
+          fi
+      - name: Debug failure (Linux)
+        if: ${{ failure() && runner.os == 'Linux' && !inputs.build_only }}
+        run: |
+          echo "IPv4 local port range:"
+          cat /proc/sys/net/ipv4/ip_local_port_range
+          echo "Netstat:"
+          netstat -an
+
+      - name: Prepare coverage report
+        if: ${{ !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
+        working-directory: ${{ env.BUILD_DIR }}
+        env:
+          BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
+          BUILD_TYPE: ${{ inputs.build_type }}
+        run: |
+          cmake \
+            --build . \
+            --config "${BUILD_TYPE}" \
+            --parallel "${BUILD_NPROC}" \
+            --target coverage
+
+      - name: Upload coverage report
+        if: ${{ github.repository == 'XRPLF/rippled' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
+        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+        with:
+          disable_search: true
+          disable_telem: true
+          fail_ci_if_error: true
+          files: ${{ env.BUILD_DIR }}/coverage.xml
+          plugins: noop
+          token: ${{ secrets.CODECOV_TOKEN }}
+          verbose: true

.github/workflows/reusable-build-test.yml

@@ -0,0 +1,62 @@
+# This workflow builds and tests the binary for various configurations.
+name: Build and test
+
+# This workflow can only be triggered by other workflows. Note that the
+# workflow_call event does not support the 'choice' input type, see
+# https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#onworkflow_callinputsinput_idtype,
+# so we use 'string' instead.
+on:
+  workflow_call:
+    inputs:
+      ccache_enabled:
+        description: "Whether to enable ccache."
+        required: false
+        type: boolean
+        default: false
+
+      os:
+        description: 'The operating system to use for the build ("linux", "macos", "windows").'
+        required: true
+        type: string
+
+      strategy_matrix:
+        # TODO: Support additional strategies, e.g. "ubuntu" for generating all Ubuntu configurations.
+        description: 'The strategy matrix to use for generating the configurations ("minimal", "all").'
+        required: false
+        type: string
+        default: "minimal"
+
+    secrets:
+      CODECOV_TOKEN:
+        description: "The Codecov token to use for uploading coverage reports."
+        required: true
+
+jobs:
+  # Generate the strategy matrix to be used by the following job.
+  generate-matrix:
+    uses: ./.github/workflows/reusable-strategy-matrix.yml
+    with:
+      os: ${{ inputs.os }}
+      strategy_matrix: ${{ inputs.strategy_matrix }}
+
+  # Build and test the binary for each configuration.
+  build-test-config:
+    needs:
+      - generate-matrix
+    uses: ./.github/workflows/reusable-build-test-config.yml
+    strategy:
+      fail-fast: ${{ github.event_name == 'merge_group' }}
+      matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
+      max-parallel: 10
+    with:
+      build_only: ${{ matrix.build_only }}
+      build_type: ${{ matrix.build_type }}
+      ccache_enabled: ${{ inputs.ccache_enabled }}
+      cmake_args: ${{ matrix.cmake_args }}
+      cmake_target: ${{ matrix.cmake_target }}
+      runs_on: ${{ toJSON(matrix.architecture.runner) }}
+      image: ${{ contains(matrix.architecture.platform, 'linux') && format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-{4}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version, matrix.os.image_sha) || '' }}
+      config_name: ${{ matrix.config_name }}
+      sanitizers: ${{ matrix.sanitizers }}
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/reusable-check-levelization.yml

@@ -0,0 +1,46 @@
+# This workflow checks if the dependencies between the modules are correctly
+# indexed.
+name: Check levelization
+
+# This workflow can only be triggered by other workflows.
+on: workflow_call
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-levelization
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  levelization:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Check levelization
+        run: python .github/scripts/levelization/generate.py
+      - name: Check for differences
+        env:
+          MESSAGE: |
+
+            The dependency relationships between the modules in xrpld have
+            changed, which may be an improvement or a regression.
+
+            A rule of thumb is that if your changes caused something to be
+            removed from loops.txt, it's probably an improvement, while if
+            something was added, it's probably a regression.
+
+            Run '.github/scripts/levelization/generate.py' in your repo, commit
+            and push the changes. See .github/scripts/levelization/README.md for
+            more info.
+        run: |
+          DIFF=$(git status --porcelain)
+          if [ -n "${DIFF}" ]; then
+            # Print the differences to give the contributor a hint about what to
+            # expect when running levelization on their own machine.
+            git diff
+            echo "${MESSAGE}"
+            exit 1
+          fi

.github/workflows/reusable-check-rename.yml

@@ -0,0 +1,56 @@
+# This workflow checks if the codebase is properly renamed, see more info in
+# .github/scripts/rename/README.md.
+name: Check rename
+
+# This workflow can only be triggered by other workflows.
+on: workflow_call
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-rename
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  rename:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Check definitions
+        run: .github/scripts/rename/definitions.sh .
+      - name: Check copyright notices
+        run: .github/scripts/rename/copyright.sh .
+      - name: Check CMake configs
+        run: .github/scripts/rename/cmake.sh .
+      - name: Check binary name
+        run: .github/scripts/rename/binary.sh .
+      - name: Check namespaces
+        run: .github/scripts/rename/namespace.sh .
+      - name: Check config name
+        run: .github/scripts/rename/config.sh .
+      - name: Check include guards
+        run: .github/scripts/rename/include.sh .
+      - name: Check documentation
+        run: .github/scripts/rename/docs.sh .
+      - name: Check for differences
+        env:
+          MESSAGE: |
+
+            One or more files contain changes that do not adhere to new naming
+            conventions.
+
+            Run the scripts in '.github/scripts/rename/' in your repo, commit
+            and push the changes. See .github/scripts/rename/README.md for
+            more info.
+        run: |
+          DIFF=$(git status --porcelain)
+          if [ -n "${DIFF}" ]; then
+            # Print the differences to give the contributor a hint about what to
+            # expect when running the renaming scripts on their own machine.
+            git diff
+            echo "${MESSAGE}"
+            exit 1
+          fi

.github/workflows/reusable-clang-tidy.yml

@@ -0,0 +1,190 @@
+name: Run clang-tidy on files
+
+on:
+  workflow_call:
+    inputs:
+      check_only_changed:
+        description: "Check only changed files in PR. If false, checks all files in the repository."
+        type: boolean
+        default: false
+      create_issue_on_failure:
+        description: "Whether to create an issue if the check failed"
+        type: boolean
+        default: false
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  BUILD_DIR: build
+  BUILD_TYPE: Debug # Debug so that ASSERTS and such participate in clang-tidy check
+
+  OUTPUT_FILE: clang-tidy-output.txt
+  DIFF_FILE: clang-tidy-git-diff.txt
+  ISSUE_FILE: clang-tidy-issue.md
+
+jobs:
+  determine-files:
+    if: ${{ inputs.check_only_changed }}
+    permissions:
+      contents: read
+    uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@224f3c48d3014d082a1129237b8291ff0b0a331f
+
+  run-clang-tidy:
+    name: Run clang tidy
+    needs: [determine-files]
+    if: ${{ always() && !cancelled() && (!inputs.check_only_changed || needs.determine-files.outputs.cpp_changed_files != '' || needs.determine-files.outputs.clang_tidy_config_changed == 'true') }}
+    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
+    container: "ghcr.io/xrplf/ci/debian-trixie:clang-21-sha-53033a2"
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
+        with:
+          enable_ccache: false
+
+      - name: Print build environment
+        uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574
+
+      - name: Get number of processors
+        uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
+        id: nproc
+
+      - name: Setup Conan
+        uses: ./.github/actions/setup-conan
+
+      - name: Build dependencies
+        uses: ./.github/actions/build-deps
+        with:
+          build_nproc: ${{ steps.nproc.outputs.nproc }}
+          build_type: ${{ env.BUILD_TYPE }}
+          log_verbosity: verbose
+
+      - name: Configure CMake
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          cmake \
+            -G 'Ninja' \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+            -Dtests=ON \
+            -Dwerr=ON \
+            -Dxrpld=ON \
+            ..
+
+      # clang-tidy needs headers generated from proto files
+      - name: Build libxrpl.libpb
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          ninja -j ${{ steps.nproc.outputs.nproc }} xrpl.libpb
+
+      - name: Run clang tidy
+        id: run_clang_tidy
+        continue-on-error: true
+        env:
+          TARGETS: ${{ (needs.determine-files.outputs.clang_tidy_config_changed != 'true' && inputs.check_only_changed) && needs.determine-files.outputs.cpp_changed_files || 'src tests' }}
+        run: |
+          set -o pipefail
+          run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" -quiet -fix -allow-no-checks ${TARGETS} 2>&1 | tee "${OUTPUT_FILE}"
+
+      - name: Print errors
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
+        run: |
+          sed '/error\||/!d' "${OUTPUT_FILE}"
+
+      - name: Upload clang-tidy output
+        if: ${{ github.event.repository.visibility == 'public' && steps.run_clang_tidy.outcome != 'success' }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          path: ${{ env.OUTPUT_FILE }}
+          archive: false
+          retention-days: 30
+
+      - name: Check for changes
+        id: files_changed
+        continue-on-error: true
+        run: |
+          git diff --exit-code
+
+      - name: Fix style
+        if: ${{ steps.files_changed.outcome != 'success' }}
+        run: |
+          pre-commit run --all-files || true
+
+      - name: Generate git diff
+        if: ${{ steps.files_changed.outcome != 'success' }}
+        run: |
+          git diff | tee "${DIFF_FILE}"
+
+      - name: Upload clang-tidy diff output
+        if: ${{ github.event.repository.visibility == 'public' && steps.files_changed.outcome != 'success' }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          path: ${{ env.DIFF_FILE }}
+          archive: false
+          retention-days: 30
+
+      - name: Write issue header
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
+        run: |
+          cat > "${ISSUE_FILE}" <<EOF
+          ## Clang-tidy Check Failed
+
+          ### Clang-tidy Output:
+          \`\`\`
+          EOF
+
+      - name: Append clang-tidy output to issue body (filter for errors and warnings)
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
+        run: |
+          if [ -f "${OUTPUT_FILE}" ]; then
+            # Extract lines containing 'error:', 'warning:', or 'note:'
+            grep -E '(error:|warning:|note:)' "${OUTPUT_FILE}" > filtered-output.txt || true
+
+            # If filtered output is empty, use original (might be a different error format)
+            if [ ! -s filtered-output.txt ]; then
+              cp "${OUTPUT_FILE}" filtered-output.txt
+            fi
+
+            # Truncate if too large
+            head -c 60000 filtered-output.txt >> "${ISSUE_FILE}"
+            if [ "$(wc -c < filtered-output.txt)" -gt 60000 ]; then
+              echo "" >> "${ISSUE_FILE}"
+              echo "... (output truncated, see artifacts for full output)" >> "${ISSUE_FILE}"
+            fi
+
+            rm filtered-output.txt
+          else
+            echo "No output file found" >> "${ISSUE_FILE}"
+          fi
+
+      - name: Append issue footer
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
+        run: |
+          cat >> "${ISSUE_FILE}" <<EOF
+          \`\`\`
+
+          ---
+          *This issue was automatically created by the clang-tidy workflow.*
+          EOF
+
+      - name: Create issue
+        if: ${{ steps.run_clang_tidy.outcome != 'success' && inputs.create_issue_on_failure }}
+        uses: XRPLF/actions/create-issue@fbcc16eb7f20dc3199eaf1aed0d3523a5ba9008c
+        with:
+          title: "Clang-tidy check failed"
+          body_file: ${{ env.ISSUE_FILE }}
+          labels: "Bug,Clang-tidy"
+          assignees: "godexsoft,mathbunnyru"
+
+      - name: Fail if clang-tidy found issues
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
+        run: |
+          echo "Clang-tidy check failed!"
+          exit 1

.github/workflows/reusable-strategy-matrix.yml

@@ -0,0 +1,45 @@
+name: Generate strategy matrix
+
+on:
+  workflow_call:
+    inputs:
+      os:
+        description: 'The operating system to use for the build ("linux", "macos", "windows").'
+        required: false
+        type: string
+      strategy_matrix:
+        # TODO: Support additional strategies, e.g. "ubuntu" for generating all Ubuntu configurations.
+        description: 'The strategy matrix to use for generating the configurations ("minimal", "all").'
+        required: false
+        type: string
+        default: "minimal"
+    outputs:
+      matrix:
+        description: "The generated strategy matrix."
+        value: ${{ jobs.generate-matrix.outputs.matrix }}
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  generate-matrix:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.generate.outputs.matrix }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: 3.13
+
+      - name: Generate strategy matrix
+        working-directory: .github/scripts/strategy-matrix
+        id: generate
+        env:
+          GENERATE_CONFIG: ${{ inputs.os != '' && format('--config={0}.json', inputs.os) || '' }}
+          GENERATE_OPTION: ${{ inputs.strategy_matrix == 'all' && '--all' || '' }}
+        run: ./generate.py ${GENERATE_OPTION} ${GENERATE_CONFIG} >> "${GITHUB_OUTPUT}"

.github/workflows/reusable-upload-recipe.yml

@@ -0,0 +1,103 @@
+# This workflow exports the built libxrpl package to the Conan remote.
+name: Upload Conan recipe
+
+# This workflow can only be triggered by other workflows.
+on:
+  workflow_call:
+    inputs:
+      remote_name:
+        description: "The name of the Conan remote to use."
+        required: false
+        type: string
+        default: xrplf
+      remote_url:
+        description: "The URL of the Conan endpoint to use."
+        required: false
+        type: string
+        default: https://conan.ripplex.io
+
+    secrets:
+      remote_username:
+        description: "The username for logging into the Conan remote."
+        required: true
+      remote_password:
+        description: "The password for logging into the Conan remote."
+        required: true
+
+    outputs:
+      recipe_ref:
+        description: "The Conan recipe reference ('name/version') that was uploaded."
+        value: ${{ jobs.upload.outputs.ref }}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-upload-recipe
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  upload:
+    runs-on: ubuntu-latest
+    container: ghcr.io/xrplf/ci/ubuntu-noble:gcc-13-sha-5dd7158
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Generate build version number
+        id: version
+        uses: ./.github/actions/generate-version
+
+      - name: Set up Conan
+        uses: ./.github/actions/setup-conan
+        with:
+          remote_name: ${{ inputs.remote_name }}
+          remote_url: ${{ inputs.remote_url }}
+
+      - name: Log into Conan remote
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+          REMOTE_USERNAME: ${{ secrets.remote_username }}
+          REMOTE_PASSWORD: ${{ secrets.remote_password }}
+        run: conan remote login "${REMOTE_NAME}" "${REMOTE_USERNAME}" --password "${REMOTE_PASSWORD}"
+
+      - name: Upload Conan recipe (version)
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+        run: |
+          conan export . --version=${{ steps.version.outputs.version }}
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/${{ steps.version.outputs.version }}
+
+      # When this workflow is triggered by a push event, it will always be when merging into the
+      # 'develop' branch, see on-trigger.yml.
+      - name: Upload Conan recipe (develop)
+        if: ${{ github.event_name == 'push' }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+        run: |
+          conan export . --version=develop
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/develop
+
+      # When this workflow is triggered by a pull request event, it will always be when merging into
+      # one of the 'release' branches, see on-pr.yml.
+      - name: Upload Conan recipe (rc)
+        if: ${{ github.event_name == 'pull_request' }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+        run: |
+          conan export . --version=rc
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/rc
+
+      # When this workflow is triggered by a push event, it will always be when tagging a final
+      # release, see on-tag.yml.
+      - name: Upload Conan recipe (release)
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+        run: |
+          conan export . --version=release
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/release
+
+    outputs:
+      ref: xrpl/${{ steps.version.outputs.version }}

.github/workflows/upload-conan-deps.yml

@@ -0,0 +1,113 @@
+name: Upload Conan Dependencies
+
+on:
+  schedule:
+    - cron: "0 3 * * 2-6"
+  workflow_dispatch:
+    inputs:
+      force_source_build:
+        description: "Force source build of all dependencies"
+        required: false
+        default: false
+        type: boolean
+      force_upload:
+        description: "Force upload of all dependencies"
+        required: false
+        default: false
+        type: boolean
+  pull_request:
+    branches: [develop]
+    paths:
+      # This allows testing changes to the upload workflow in a PR
+      - .github/workflows/upload-conan-deps.yml
+  push:
+    branches: [develop]
+    paths:
+      - .github/workflows/upload-conan-deps.yml
+      - .github/workflows/reusable-strategy-matrix.yml
+      - .github/actions/build-deps/action.yml
+      - .github/actions/setup-conan/action.yml
+      - ".github/scripts/strategy-matrix/**"
+      - conanfile.py
+      - conan.lock
+
+env:
+  CONAN_REMOTE_NAME: xrplf
+  CONAN_REMOTE_URL: https://conan.ripplex.io
+  NPROC_SUBTRACT: 2
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  # Generate the strategy matrix to be used by the following job.
+  generate-matrix:
+    uses: ./.github/workflows/reusable-strategy-matrix.yml
+    with:
+      strategy_matrix: ${{ github.event_name == 'pull_request' && 'minimal' || 'all' }}
+
+  # Build and upload the dependencies for each configuration.
+  run-upload-conan-deps:
+    needs:
+      - generate-matrix
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
+      max-parallel: 10
+    runs-on: ${{ matrix.architecture.runner }}
+    container: ${{ contains(matrix.architecture.platform, 'linux') && format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-{4}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version, matrix.os.image_sha) || null }}
+    steps:
+      - name: Cleanup workspace (macOS and Windows)
+        if: ${{ runner.os == 'macOS' || runner.os == 'Windows' }}
+        uses: XRPLF/actions/cleanup-workspace@c7d9ce5ebb03c752a354889ecd870cadfc2b1cd4
+
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
+        with:
+          enable_ccache: false
+
+      - name: Print build environment
+        uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574
+
+      - name: Get number of processors
+        uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
+        id: nproc
+        with:
+          subtract: ${{ env.NPROC_SUBTRACT }}
+
+      - name: Setup Conan
+        env:
+          SANITIZERS: ${{ matrix.sanitizers }}
+        uses: ./.github/actions/setup-conan
+        with:
+          remote_name: ${{ env.CONAN_REMOTE_NAME }}
+          remote_url: ${{ env.CONAN_REMOTE_URL }}
+
+      - name: Build dependencies
+        uses: ./.github/actions/build-deps
+        with:
+          build_nproc: ${{ steps.nproc.outputs.nproc }}
+          build_type: ${{ matrix.build_type }}
+          force_build: ${{ github.event_name == 'schedule' || github.event.inputs.force_source_build == 'true' }}
+          # Set the verbosity to "quiet" for Windows to avoid an excessive
+          # amount of logs. For other OSes, the "verbose" logs are more useful.
+          log_verbosity: ${{ runner.os == 'Windows' && 'quiet' || 'verbose' }}
+          sanitizers: ${{ matrix.sanitizers }}
+
+      - name: Log into Conan remote
+        if: ${{ github.repository == 'XRPLF/rippled' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}
+        run: conan remote login "${CONAN_REMOTE_NAME}" "${{ secrets.CONAN_REMOTE_USERNAME }}" --password "${{ secrets.CONAN_REMOTE_PASSWORD }}"
+
+      - name: Upload Conan packages
+        if: ${{ github.repository == 'XRPLF/rippled' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}
+        env:
+          FORCE_OPTION: ${{ github.event.inputs.force_upload == 'true' && '--force' || '' }}
+        run: conan upload "*" --remote="${CONAN_REMOTE_NAME}" --confirm ${FORCE_OPTION}

.gitignore

@@ -1,61 +1,62 @@
 # .gitignore
+# cspell: disable
 
-bin/boostbook_catalog.xml
-bin/config.log
-bin/project-cache.jam
+# AI-generated documentation source (temporary, used by doc-agent
+# during the initial documentation pass; removed once docs are merged).
+*.ai.md
 
-# Ignore vim swap files.
-*.swp
-
-# Ignore SCons support files.
-.sconsign.dblite
-
-# Ignore python compiled files.
-*.pyc
-
-# Ignore Macintosh Desktop Services Store files.
+# Macintosh Desktop Services Store files.
 .DS_Store
 
-# Ignore backup/temps
+# Build, intermediate, and temporary artifacts.
 *~
-
-# Ignore object files.
 *.o
-build
-tags
-TAGS
-bin/rippled
-Debug/*.*
-Release/*.*
+*.pdb
+*.swp
+/.clangd
+Debug/
+Release/
+/.build/
+/.venv/
+/build/
+/build-base/
+/doc-coverage.info
+/base-doc-coverage.info
+/doc-coverage-report.md
+/doc-review-report.md
+/doc-review-comments.json
+/db/
+/out.txt
+/Testing/
+/tmp/
+CMakeSettings.json
+CMakeUserPresets.json
 
-# Ignore coverage files.
+# Coverage files.
 *.gcno
 *.gcda
 *.gcov
 
-# Ignore tmp directory.
-tmp
+# Profiling data.
+gmon.out
 
-# Ignore database directory.
-db/
-db/*.db
-db/*.db-*
+# Levelization data.
+.github/scripts/levelization/results/*
+!.github/scripts/levelization/results/loops.txt
+!.github/scripts/levelization/results/ordering.txt
 
-# Ignore debug logs
-debug_log.txt
+# Customized configs.
+/rippled.cfg
+/xrpld.cfg
+/validators.txt
 
-# Ignore customized configs
-rippled.cfg
-validators.txt
+# Locally patched Conan recipes
+external/conan-center-index/
 
-# Doxygen generated documentation output
-HtmlDocumentation
-docs/html_doc
+# Local conan directory
+.conan
 
-# Xcode user-specific project settings
-# Xcode
-.DS_Store
-*/build/*
+# XCode IDE.
 *.pbxuser
 !default.pbxuser
 *.mode1v3
@@ -68,26 +69,30 @@ xcuserdata
 profile
 *.moved-aside
 DerivedData
-.idea/
 *.hmap
 
-# Intel Parallel Studio 2013 XE
-My Amplifier XE Results - RippleD
+# JetBrains IDE.
+/.idea/
 
-# Compiler intermediate output
-/out.txt
+# Microsoft Visual Studio IDE.
+/.vs/
+/.vscode/
 
-# Build Log
-rippled-build.log
+# zed IDE.
+/.zed/
 
-# Profiling data
-gmon.out
+# AI tools.
+/.agent
+/.agents
+/.augment
+/.claude
+/CLAUDE.md
 
-Builds/VisualStudio2015/*.db
-Builds/VisualStudio2015/*.user
-Builds/VisualStudio2015/*.opendb
-Builds/VisualStudio2015/*.sdf
+# Python
+__pycache__
 
-# MSVC
-*.pdb
-.vs/
+# Direnv's directory
+/.direnv
+
+# clangd cache
+/.cache

.gitmodules

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

.pre-commit-config.yaml

@@ -0,0 +1,111 @@
+# To run pre-commit hooks, first install pre-commit:
+# - `pip install pre-commit==${PRE_COMMIT_VERSION}`
+#
+# Then, run the following command to install the git hook scripts:
+# - `pre-commit install`
+# You can run all configured hooks against all files with:
+# - `pre-commit run --all-files`
+# To manually run a specific hook, use:
+# - `pre-commit run <hook_id> --all-files`
+# To run the hooks against only the staged files, use:
+# - `pre-commit run`
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: 3e8a8703264a2f4a69428a0aa4dcb512790b2c8c # frozen: v6.0.0
+    hooks:
+      - id: check-added-large-files
+        args: [--maxkb=400, --enforce-all]
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-merge-conflict
+        args: [--assume-in-merge]
+
+  - repo: local
+    hooks:
+      - id: clang-tidy
+        name: "clang-tidy (enable with: TIDY=1)"
+        entry: ./bin/pre-commit/clang_tidy_check.py
+        language: python
+        types_or: [c++, c]
+        exclude: ^include/xrpl/protocol_autogen
+        pass_filenames: false # script determines the staged files itself
+      - id: fix-include-style
+        name: fix include style
+        entry: ./bin/pre-commit/fix_include_style.py
+        language: python
+        types_or: [c++, c]
+        exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_entries)/
+
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: cd481d7b0bfb5c7b3090c21846317f9a8262e891 # frozen: v22.1.0
+    hooks:
+      - id: clang-format
+        args: [--style=file]
+        "types_or": [c++, c, proto]
+        exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_entries)/
+
+  - repo: https://github.com/BlankSpruce/gersemi
+    rev: 0.26.0
+    hooks:
+      - id: gersemi
+
+  - repo: https://github.com/rbubley/mirrors-prettier
+    rev: c2bc67fe8f8f549cc489e00ba8b45aa18ee713b1 # frozen: v3.8.1
+    hooks:
+      - id: prettier
+        args: [--end-of-line=auto]
+
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: ea488cebbfd88a5f50b8bd95d5c829d0bb76feb8 # frozen: 26.1.0
+    hooks:
+      - id: black
+
+  - repo: https://github.com/openstack/bashate
+    rev: 5798d24d571676fc407e81df574c1ef57b520f23 # frozen: 2.1.1
+    hooks:
+      - id: bashate
+        args: ["--ignore=E006"]
+
+  - repo: https://github.com/streetsidesoftware/cspell-cli
+    rev: a42085ade523f591dca134379a595e7859986445 # frozen: v9.7.0
+    hooks:
+      - id: cspell # Spell check changed files
+        exclude: |
+          (?x)^(
+              .config/cspell.config.yaml|
+              include/xrpl/protocol_autogen/(transactions|ledger_entries)/.*
+          )$
+      - id: cspell # Spell check the commit message
+        name: check commit message spelling
+        args:
+          - --no-must-find-files
+          - --no-progress
+          - --no-summary
+          - --files
+          - .git/COMMIT_EDITMSG
+        stages: [commit-msg]
+
+  - repo: local
+    hooks:
+      - id: nix-fmt
+        name: Format Nix files
+        entry: |
+          bash -c '
+            if command -v nix &> /dev/null || [ "$GITHUB_ACTIONS" = "true" ]; then
+              nix --extra-experimental-features "nix-command flakes" fmt "$@"
+            else
+              echo "Skipping nix-fmt: nix not installed and not in GitHub Actions"
+              exit 0
+            fi
+          ' --
+        language: system
+        types:
+          - nix
+        pass_filenames: true
+
+exclude: |
+  (?x)^(
+      external/.*|
+      .github/scripts/levelization/results/.*\.txt|
+      src/tests/libxrpl/protocol_autogen/(transactions|ledger_entries)/.*
+  )$

.prettierignore

@@ -0,0 +1 @@
+external

.travis.yml

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

API-CHANGELOG.md

@@ -0,0 +1,262 @@
+# 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 `xrpld` API, a new version is released. To avoid breaking your code, you should set (or increase) your version when you're ready to upgrade.
+
+The [commandline](https://xrpl.org/docs/references/http-websocket-apis/api-conventions/request-formatting/#commandline-format) always uses the latest API version. The command line is intended for ad-hoc usage by humans, not programs or automated scripts. The command line is not meant for use in production code.
+
+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 (`xrpld`) release.
+
+## API Version 3 (Beta)
+
+API version 3 is currently a beta API. It requires enabling `[beta_rpc_api]` in the xrpld configuration to use. See [API-VERSION-3.md](API-VERSION-3.md) for the full list of changes in API version 3.
+
+## API Version 2
+
+API version 2 is available in `xrpld` version 2.0.0 and later. See [API-VERSION-2.md](API-VERSION-2.md) for the full list of changes in API version 2.
+
+## API Version 1
+
+This version is supported by all `xrpld` versions. For WebSocket and HTTP JSON-RPC requests, it is currently the default API version used when no `api_version` is specified.
+
+## Unreleased
+
+This section contains changes targeting a future version.
+
+### Additions
+
+- `ledger_entry`, `account_objects`: The `Delegate` ledger entry now includes an optional `DestinationNode` field, which stores the index into the authorized account's owner directory. This field is present on entries created after bidirectional directory tracking was introduced and may appear in RPC responses for those entries. ([#6681](https://github.com/XRPLF/rippled/pull/6681))
+
+- `server_definitions`: Added the following new sections to the response ([#6321](https://github.com/XRPLF/rippled/pull/6321)):
+  - `TRANSACTION_FORMATS`: Describes the fields and their optionality for each transaction type, including common fields shared across all transactions.
+  - `LEDGER_ENTRY_FORMATS`: Describes the fields and their optionality for each ledger entry type, including common fields shared across all ledger entries.
+  - `TRANSACTION_FLAGS`: Maps transaction type names to their supported flags and flag values.
+  - `LEDGER_ENTRY_FLAGS`: Maps ledger entry type names to their flags and flag values.
+  - `ACCOUNT_SET_FLAGS`: Maps AccountSet flag names (asf flags) to their numeric values.
+
+### Bugfixes
+
+- Peer Crawler: The `port` field in `overlay.active[]` now consistently returns an integer instead of a string for outbound peers. [#6318](https://github.com/XRPLF/rippled/pull/6318)
+- `ping`: The `ip` field is no longer returned as an empty string for proxied connections without a forwarded-for header. It is now omitted, consistent with the behavior for identified connections. [#6730](https://github.com/XRPLF/rippled/pull/6730)
+- gRPC `GetLedgerDiff`: Fixed error message that incorrectly said "base ledger not validated" when the desired ledger was not validated. [#6730](https://github.com/XRPLF/rippled/pull/6730)
+- `account_channels`: The `destination_account` field now returns an error if the value is not a string. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `subscribe`: The `taker` field in the `books` array now returns an error if the value is not a string. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `account_info`: The `urlgravatar` field now uses HTTPS instead of HTTP. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `ledger`: The `full`, `accounts`, `transactions`, `expand`, `binary`, `owner_funds`, and `queue` fields now return an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `ledger_data`: The `binary` field now returns an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `submit`: The `fail_hard` field now returns an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `subscribe`: The `taker` field in the `books` array now returns `actMalformed` instead of `badIssuer` if the value is not a valid account. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- Fixed a bug in `Forwarded` HTTP header parsing where the extracted IP address could be incorrect when no comma or semicolon delimiter follows the address. This could cause the server to misidentify a client's IP address when operating behind a reverse proxy. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+
+## XRP Ledger server version 3.1.0
+
+[Version 3.1.0](https://github.com/XRPLF/rippled/releases/tag/3.1.0) was released on Jan 27, 2026.
+
+### Additions in 3.1.0
+
+- `vault_info`: New RPC method to retrieve information about a specific vault (part of XLS-66 Lending Protocol). ([#6156](https://github.com/XRPLF/rippled/pull/6156))
+
+## XRP Ledger server version 3.0.0
+
+[Version 3.0.0](https://github.com/XRPLF/rippled/releases/tag/3.0.0) was released on Dec 9, 2025.
+
+### Additions in 3.0.0
+
+- `ledger_entry`: Supports all ledger entry types with dedicated parsers. ([#5237](https://github.com/XRPLF/rippled/pull/5237))
+- `ledger_entry`: New error codes `entryNotFound` and `unexpectedLedgerType` for more specific error handling. ([#5237](https://github.com/XRPLF/rippled/pull/5237))
+- `ledger_entry`: Improved error messages with more context (e.g., specifying which field is invalid or missing). ([#5237](https://github.com/XRPLF/rippled/pull/5237))
+- `ledger_entry`: Assorted bug fixes in RPC processing. ([#5237](https://github.com/XRPLF/rippled/pull/5237))
+- `simulate`: Supports additional metadata in the response. ([#5754](https://github.com/XRPLF/rippled/pull/5754))
+
+## XRP Ledger server version 2.6.2
+
+[Version 2.6.2](https://github.com/XRPLF/rippled/releases/tag/2.6.2) was released on Nov 19, 2025.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 2.6.1
+
+[Version 2.6.1](https://github.com/XRPLF/rippled/releases/tag/2.6.1) was released on Sep 30, 2025.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 2.6.0
+
+[Version 2.6.0](https://github.com/XRPLF/rippled/releases/tag/2.6.0) was released on Aug 27, 2025.
+
+### Additions in 2.6.0
+
+- `account_info`: Added `allowTrustLineLocking` flag in response. ([#5525](https://github.com/XRPLF/rippled/pull/5525))
+- `ledger`: Removed the type filter from the RPC command. ([#4934](https://github.com/XRPLF/rippled/pull/4934))
+- `subscribe` (`validations` stream): `network_id` is now included. ([#5579](https://github.com/XRPLF/rippled/pull/5579))
+- `subscribe` (`transactions` stream): `nftoken_id`, `nftoken_ids`, and `offer_id` are now included in transaction metadata. ([#5230](https://github.com/XRPLF/rippled/pull/5230))
+
+## XRP Ledger server version 2.5.1
+
+[Version 2.5.1](https://github.com/XRPLF/rippled/releases/tag/2.5.1) was released on Sep 17, 2025.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 2.5.0
+
+[Version 2.5.0](https://github.com/XRPLF/rippled/releases/tag/2.5.0) was released on Jun 24, 2025.
+
+### Additions and bugfixes in 2.5.0
+
+- `tx`: Added `ctid` field to the response and improved error handling. ([#4738](https://github.com/XRPLF/rippled/pull/4738))
+- `ledger_entry`: Improved error messages in `permissioned_domain`. ([#5344](https://github.com/XRPLF/rippled/pull/5344))
+- `simulate`: Improved multi-sign usage. ([#5479](https://github.com/XRPLF/rippled/pull/5479))
+- `channel_authorize`: If `signing_support` is not enabled in the config, the RPC is disabled. ([#5385](https://github.com/XRPLF/rippled/pull/5385))
+- `subscribe` (admin): Removed webhook queue limit to prevent dropping notifications; reduced HTTP timeout from 10 minutes to 30 seconds. ([#5163](https://github.com/XRPLF/rippled/pull/5163))
+- `ledger_data` (gRPC): Fixed crashing issue with some invalid markers. ([#5137](https://github.com/XRPLF/rippled/pull/5137))
+- `account_lines`: Fixed error with `no_ripple` and `no_ripple_peer` sometimes showing up incorrectly. ([#5345](https://github.com/XRPLF/rippled/pull/5345))
+- `account_tx`: Fixed issue with incorrect CTIDs. ([#5408](https://github.com/XRPLF/rippled/pull/5408))
+
+## XRP Ledger server version 2.4.0
+
+[Version 2.4.0](https://github.com/XRPLF/rippled/releases/tag/2.4.0) was released on March 4, 2025.
+
+### Additions and bugfixes in 2.4.0
+
+- `simulate`: A new RPC that executes a [dry run of a transaction submission](https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0069d-simulate#2-rpc-simulate). ([#5069](https://github.com/XRPLF/rippled/pull/5069))
+- Signing methods (`sign`, `sign_for`, `submit`): Autofill fees better, properly handle transactions without a base fee, and autofill the `NetworkID` field. ([#5069](https://github.com/XRPLF/rippled/pull/5069))
+- `ledger_entry`: `state` is added as an alias for `ripple_state`. ([#5199](https://github.com/XRPLF/rippled/pull/5199))
+- `ledger`, `ledger_data`, `account_objects`: Support filtering ledger entry types by their canonical names (case-insensitive). ([#5271](https://github.com/XRPLF/rippled/pull/5271))
+- `validators`: Added new field `validator_list_threshold` in response. ([#5112](https://github.com/XRPLF/rippled/pull/5112))
+- `server_info`: Added git commit hash info on admin connection. ([#5225](https://github.com/XRPLF/rippled/pull/5225))
+- `server_definitions`: Changed larger `UInt` serialized types to `Hash`. ([#5231](https://github.com/XRPLF/rippled/pull/5231))
+
+## XRP Ledger server version 2.3.1
+
+[Version 2.3.1](https://github.com/XRPLF/rippled/releases/tag/2.3.1) was released on Jan 29, 2025.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 2.3.0
+
+[Version 2.3.0](https://github.com/XRPLF/rippled/releases/tag/2.3.0) was released on Nov 25, 2024.
+
+### Breaking changes in 2.3.0
+
+- `book_changes`: If the requested ledger version is not available on this node, a `ledgerNotFound` error is returned and the node does not attempt to acquire the ledger from the p2p network (as with other non-admin RPCs). Admins can still attempt to retrieve old ledgers with the `ledger_request` RPC.
+
+### Additions and bugfixes in 2.3.0
+
+- `book_changes`: Returns a `validated` field in its response. ([#5096](https://github.com/XRPLF/rippled/pull/5096))
+- `book_changes`: Accepts shortcut strings (`current`, `closed`, `validated`) for the `ledger_index` parameter. ([#5096](https://github.com/XRPLF/rippled/pull/5096))
+- `server_definitions`: Include `index` in response. ([#5190](https://github.com/XRPLF/rippled/pull/5190))
+- `account_nfts`: Fix issue where unassociated marker would return incorrect results. ([#5045](https://github.com/XRPLF/rippled/pull/5045))
+- `account_objects`: Fix issue where invalid marker would not return an error. ([#5046](https://github.com/XRPLF/rippled/pull/5046))
+- `account_objects`: Disallow filtering by ledger entry types that an account cannot hold. ([#5056](https://github.com/XRPLF/rippled/pull/5056))
+- `tx`: Allow lowercase CTID. ([#5049](https://github.com/XRPLF/rippled/pull/5049))
+- `feature`: Better error handling for invalid values of `feature`. ([#5063](https://github.com/XRPLF/rippled/pull/5063))
+
+## XRP Ledger server version 2.2.0
+
+[Version 2.2.0](https://github.com/XRPLF/rippled/releases/tag/2.2.0) was released on Jun 5, 2024. The following additions are non-breaking (because they are purely additive):
+
+- `feature`: Add a non-admin mode for users. (It was previously only available to admin connections.) The method returns an updated list of amendments, including their names and other information. ([#4781](https://github.com/XRPLF/rippled/pull/4781))
+
+## XRP Ledger server version 2.0.1
+
+[Version 2.0.1](https://github.com/XRPLF/rippled/releases/tag/2.0.1) was released on Jan 29, 2024. The following additions are non-breaking:
+
+- `path_find`: Fixes unbounded memory growth. ([#4822](https://github.com/XRPLF/rippled/pull/4822))
+
+## XRP Ledger server version 2.0.0
+
+[Version 2.0.0](https://github.com/XRPLF/rippled/releases/tag/2.0.0) was released on Jan 9, 2024. The following additions are non-breaking (because they are purely additive):
+
+- `server_definitions`: A new RPC that generates a `definitions.json`-like output that can be used in XRPL libraries.
+- In `Payment` transactions, `DeliverMax` has been added. This is a replacement for the `Amount` field, which should not be used. Typically, the `delivered_amount` (in transaction metadata) should be used. To ease the transition, `DeliverMax` is present regardless of API version, since adding a field is non-breaking.
+- API version 2 has been moved from beta to supported, meaning that it is generally available (regardless of the `beta_rpc_api` setting). The full list of changes is in [API-VERSION-2.md](API-VERSION-2.md).
+
+## XRP Ledger server version 1.12.0
+
+[Version 1.12.0](https://github.com/XRPLF/rippled/releases/tag/1.12.0) was released on Sep 6, 2023. The following additions are non-breaking (because they are purely additive):
+
+- `server_info`: Added `ports`, an array which advertises the RPC and WebSocket ports. This information is also included in the `/crawl` endpoint (which calls `server_info` internally). `grpc` and `peer` ports are also included. ([#4427](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`). ([#4553](https://github.com/XRPLF/rippled/pull/4553))
+  - Adds an [AccountRoot flag](https://xrpl.org/accountroot.html#accountroot-flags) called `lsfAllowTrustLineClawback`. ([#4617](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. ([#4291](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. ([#4404](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. ([#4398](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`. ([#4370](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. ([#4447](https://github.com/XRPLF/rippled/pull/4447))
+- Added an `account_flags` object to the `account_info` method response. ([#4459](https://github.com/XRPLF/rippled/pull/4459))
+- Added `NFTokenPages` to the `account_objects` RPC. ([#4352](https://github.com/XRPLF/rippled/pull/4352))
+- Fixed: `marker` returned from the `account_lines` command would not work on subsequent commands. ([#4361](https://github.com/XRPLF/rippled/pull/4361))
+
+## XRP Ledger server version 1.10.0
+
+[Version 1.10.0](https://github.com/XRPLF/rippled/releases/tag/1.10.0)
+was released on Mar 14, 2023.
+
+### Breaking changes in 1.10
+
+- If the `XRPFees` feature is enabled, the `fee_ref` field will be
+  removed from the [ledger subscription stream](https://xrpl.org/subscribe.html#ledger-stream), because it will no longer
+  have any meaning.
+
+# Unit tests for API changes
+
+The following information is useful to developers contributing to this project:
+
+The purpose of unit tests is to catch bugs and prevent regressions. In general, it often makes sense to create a test function when there is a breaking change to the API. For APIs that have changed in a new API version, the tests should be modified so that both the prior version and the new version are properly tested.
+
+To take one example: for `account_info` version 1, WebSocket and JSON-RPC behavior should be tested. The latest API version, i.e. API version 2, should be tested over WebSocket, JSON-RPC, and command line.

API-VERSION-2.md

@@ -0,0 +1,66 @@
+# API Version 2
+
+API version 2 is available in `xrpld` version 2.0.0 and later. To use this API, clients specify `"api_version" : 2` in each request.
+
+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.
+
+## Removed methods
+
+In API version 2, the following deprecated methods are no longer available: ([#4759](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 API version 2
+
+In API version 2, JSON elements for transaction output have been changed and made consistent for all methods which output transactions. ([#4775](https://github.com/XRPLF/rippled/pull/4775))
+This helps to unify the JSON serialization format of transactions. ([clio#722](https://github.com/XRPLF/clio/issues/722), [#4727](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.
+
+## Modifications 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`. ([#4733](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: ([#4733](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`.) ([#3770](https://github.com/XRPLF/rippled/pull/3770))
+- When using an invalid `signer_lists` value, the API now returns an "invalidParams" error. ([#4585](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. ([#4571](https://github.com/XRPLF/rippled/pull/4571))
+  - The same applies for `ledger_index_min`, `ledger_index_max`, and `ledger_hash`. ([#4545](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. ([#4288](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. ([#4620](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. ([#4620](https://github.com/XRPLF/rippled/pull/4620))

API-VERSION-3.md

@@ -0,0 +1,27 @@
+# API Version 3
+
+API version 3 is currently a **beta API**. It requires enabling `[beta_rpc_api]` in the xrpld configuration to use. To use this API, clients specify `"api_version" : 3` in each request.
+
+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.
+
+## Breaking Changes
+
+### Modifications to `amm_info`
+
+The order of error checks has been changed to provide more specific error messages. ([#4924](https://github.com/XRPLF/rippled/pull/4924))
+
+- **Before (API v2)**: When sending an invalid account or asset to `amm_info` while other parameters are not set as expected, the method returns a generic `rpcINVALID_PARAMS` error.
+- **After (API v3)**: The same scenario returns a more specific error: `rpcISSUE_MALFORMED` for malformed assets or `rpcACT_MALFORMED` for malformed accounts.
+
+### Modifications to `ledger_entry`
+
+Added support for string shortcuts to look up fixed-location ledger entries using the `"index"` parameter. ([#5644](https://github.com/XRPLF/rippled/pull/5644))
+
+In API version 3, the following string values can be used with the `"index"` parameter:
+
+- `"index": "amendments"` - Returns the `Amendments` ledger entry
+- `"index": "fee"` - Returns the `FeeSettings` ledger entry
+- `"index": "nunl"` - Returns the `NegativeUNL` ledger entry
+- `"index": "hashes"` - Returns the "short" `LedgerHashes` ledger entry (recent ledger hashes)
+
+These shortcuts are only available in API version 3 and later. In API versions 1 and 2, these string values would result in an error.

BUILD.md

@@ -0,0 +1,634 @@
+| :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/XRPLF/rippled/releases).
+
+```bash
+git checkout master
+```
+
+For the latest release candidate, choose the `release` branch.
+
+```bash
+git checkout release
+```
+
+For the latest set of untested features, or to contribute, choose the `develop`
+branch.
+
+```bash
+git checkout develop
+```
+
+## Minimum Requirements
+
+See [System Requirements](https://xrpl.org/system-requirements.html).
+
+Building xrpld 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.11](https://www.python.org/downloads/), or higher
+- [Conan 2.17](https://conan.io/downloads.html)[^1], or higher
+- [CMake 3.22](https://cmake.org/download/), or higher
+
+[^1]:
+    It is possible to build with Conan 1.60+, but the instructions are
+    significantly different, which is why we are not recommending it.
+
+`xrpld` is written in the C++20 dialect and includes the `<concepts>` header.
+The [minimum compiler versions][2] required are:
+
+| Compiler    | Version   |
+| ----------- | --------- |
+| GCC         | 12        |
+| Clang       | 16        |
+| Apple Clang | 16        |
+| MSVC        | 19.44[^3] |
+
+### Linux
+
+The Ubuntu Linux distribution has received the highest level of quality
+assurance, testing, and support. We also support Red Hat and use Debian
+internally.
+
+Here are [sample instructions for setting up a C++ development environment on
+Linux](./docs/build/environment.md#linux).
+
+### Mac
+
+Many xrpld 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 used by some engineers for development only.
+
+[^3]: Windows is not recommended for production use.
+
+## 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.
+
+#### Conan lockfile
+
+To achieve reproducible dependencies, we use a [Conan lockfile](https://docs.conan.io/2/tutorial/versioning/lockfiles.html),
+which has to be updated every time dependencies change.
+
+Please see the [instructions on how to regenerate the lockfile](conan/lockfile/README.md).
+
+#### Default profile
+
+We recommend that you import the provided `conan/profiles/default` profile:
+
+```bash
+conan config install conan/profiles/ -tf $(conan config home)/profiles/
+```
+
+You can check your Conan profile by running:
+
+```bash
+conan profile show
+```
+
+#### Custom profile
+
+If the default profile does not work for you and you do not yet have a Conan
+profile, you can create one by running:
+
+```bash
+conan profile detect
+```
+
+You may need to make changes to the profile to suit your environment. You can
+refer to the provided `conan/profiles/default` profile for inspiration, and you
+may also need to apply the required [tweaks](#conan-profile-tweaks) to this
+default profile.
+
+### Patched recipes
+
+Occasionally, we need patched recipes or recipes not present in Conan Center.
+We maintain a fork of the Conan Center Index
+[here](https://github.com/XRPLF/conan-center-index/) containing the modified and newly added recipes.
+
+To ensure our patched recipes are used, you must add our Conan remote at a
+higher index than the default Conan Center remote, so it is consulted first. You
+can do this by running:
+
+```bash
+conan remote add --index 0 xrplf https://conan.ripplex.io
+```
+
+Alternatively, you can pull our recipes from the repository and export them locally:
+
+```bash
+# Define which recipes to export.
+recipes=('abseil' 'ed25519' 'mpt-crypto' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi')
+
+# Selectively check out the recipes from our CCI fork.
+cd external
+mkdir -p conan-center-index
+cd conan-center-index
+git init
+git remote add origin git@github.com:XRPLF/conan-center-index.git
+git sparse-checkout init
+for recipe in "${recipes[@]}"; do
+  echo "Checking out recipe '${recipe}'..."
+  git sparse-checkout add recipes/${recipe}
+done
+git fetch origin master
+git checkout master
+
+./export_all.sh
+cd ../../
+```
+
+In the case we switch to a newer version of a dependency that still requires a
+patch or add a new dependency, it will be necessary for you to pull in the changes and re-export the
+updated dependencies with the newer version. However, if we switch to a newer
+version that no longer requires a patch, no action is required on your part, as
+the new recipe will be automatically pulled from the official Conan Center.
+
+> [!NOTE]
+> You might need to add `--lockfile=""` to your `conan install` command
+> to avoid automatic use of the existing `conan.lock` file when you run
+> `conan export` manually on your machine
+>
+> This is not recommended though, as you might end up using different revisions of recipes.
+
+### Conan profile tweaks
+
+#### Missing compiler version
+
+If you see an error similar to the following after running `conan profile show`:
+
+```bash
+ERROR: Invalid setting '17' is not a valid 'settings.compiler.version' value.
+Possible values are ['5.0', '5.1', '6.0', '6.1', '7.0', '7.3', '8.0', '8.1',
+'9.0', '9.1', '10.0', '11.0', '12.0', '13', '13.0', '13.1', '14', '14.0', '15',
+'15.0', '16', '16.0']
+Read "http://docs.conan.io/2/knowledge/faq.html#error-invalid-setting"
+```
+
+you need to add your compiler to the list of compiler versions in
+`$(conan config home)/settings_user.yml`, by adding the required version number(s)
+to the `version` array specific for your compiler. For example:
+
+```yaml
+compiler:
+  apple-clang:
+    version: ["17.0"]
+```
+
+#### Multiple compilers
+
+If you have multiple compilers installed, make sure to select the one to use in
+your default Conan configuration **before** running `conan profile detect`, by
+setting the `CC` and `CXX` environment variables.
+
+For example, if you are running MacOS and have [homebrew
+LLVM@18](https://formulae.brew.sh/formula/llvm@18), and want to use it as a
+compiler in the new Conan profile:
+
+```bash
+export CC=$(brew --prefix llvm@18)/bin/clang
+export CXX=$(brew --prefix llvm@18)/bin/clang++
+conan profile detect
+```
+
+You should also explicitly set the path to the compiler in the profile file,
+which helps to avoid errors when `CC` and/or `CXX` are set and disagree with the
+selected Conan profile. For example:
+
+```text
+[conf]
+tools.build:compiler_executables={'c':'/usr/bin/gcc','cpp':'/usr/bin/g++'}
+```
+
+#### Multiple profiles
+
+You can manage multiple Conan profiles in the directory
+`$(conan config home)/profiles`, for example renaming `default` to a different
+name and then creating a new `default` profile for a different compiler.
+
+#### Select language
+
+The default profile created by Conan will typically select different C++ dialect
+than C++20 used by this project. You should set `20` in the profile line
+starting with `compiler.cppstd=`. For example:
+
+```bash
+sed -i.bak -e 's|^compiler\.cppstd=.*$|compiler.cppstd=20|' $(conan config home)/profiles/default
+```
+
+#### Select standard library in Linux
+
+**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:
+
+```bash
+sed -i.bak -e 's|^compiler\.libcxx=.*$|compiler.libcxx=libstdc++11|' $(conan config home)/profiles/default
+```
+
+#### Select architecture and runtime in Windows
+
+**Windows** developers may need to use the x64 native build tools. An easy way
+to do that is to run the shortcut "x64 Native Tools Command Prompt" for the
+version of Visual Studio that you have installed.
+
+Windows developers must also build `xrpld` and its dependencies for the x64
+architecture:
+
+```bash
+sed -i.bak -e 's|^arch=.*$|arch=x86_64|' $(conan config home)/profiles/default
+```
+
+**Windows** developers also must select static runtime:
+
+```bash
+sed -i.bak -e 's|^compiler\.runtime=.*$|compiler.runtime=static|' $(conan config home)/profiles/default
+```
+
+#### Clang workaround for grpc
+
+If your compiler is clang, version 19 or later, or apple-clang, version 17 or
+later, you may encounter a compilation error while building the `grpc`
+dependency:
+
+```text
+In file included from .../lib/promise/try_seq.h:26:
+.../lib/promise/detail/basic_seq.h:499:38: error: a template argument list is expected after a name prefixed by the template keyword [-Wmissing-template-arg-list-after-template-kw]
+  499 |                     Traits::template CallSeqFactory(f_, *cur_, std::move(arg)));
+      |                                      ^
+```
+
+The workaround for this error is to add two lines to profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
+```
+
+#### Workaround for gcc 12
+
+If your compiler is gcc, version 12, and you have enabled `werr` option, you may
+encounter a compilation error such as:
+
+```text
+/usr/include/c++/12/bits/char_traits.h:435:56: error: 'void* __builtin_memcpy(void*, const void*, long unsigned int)' accessing 9223372036854775810 or more bytes at offsets [2, 9223372036854775807] and 1 may overlap up to 9223372036854775813 bytes at offset -3 [-Werror=restrict]
+  435 |         return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
+      |                                        ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
+cc1plus: all warnings being treated as errors
+```
+
+The workaround for this error is to add two lines to your profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-Wno-restrict']
+```
+
+#### Workaround for clang 16
+
+If your compiler is clang, version 16, you may encounter compilation error such
+as:
+
+```text
+In file included from .../boost/beast/websocket/stream.hpp:2857:
+.../boost/beast/websocket/impl/read.hpp:695:17: error: call to 'async_teardown' is ambiguous
+                async_teardown(impl.role, impl.stream(),
+                ^~~~~~~~~~~~~~
+```
+
+The workaround for this error is to add two lines to your profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-DBOOST_ASIO_DISABLE_CONCEPTS']
+```
+
+### Set Up Ccache
+
+To speed up repeated compilations, we recommend that you install
+[ccache](https://ccache.dev), a tool that wraps your compiler so that it can
+cache build objects locally.
+
+#### Linux
+
+You can install it using the package manager, e.g. `sudo apt install ccache`
+(Ubuntu) or `sudo dnf install ccache` (RHEL).
+
+#### macOS
+
+You can install it using Homebrew, i.e. `brew install ccache`.
+
+#### Windows
+
+You can install it using Chocolatey, i.e. `choco install ccache`. If you already
+have Ccache installed, then `choco upgrade ccache` will update it to the latest
+version. However, if you see an error such as:
+
+```
+terminate called after throwing an instance of 'std::bad_alloc'
+      what():  std::bad_alloc
+C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Microsoft\VC\v170\Microsoft.CppCommon.targets(617,5): error MSB6006: "cl.exe" exited with code 3.
+```
+
+then please install a specific version of Ccache that we know works, via: `choco
+install ccache --version 4.11.3 --allow-downgrade`.
+
+### Build and Test
+
+1. Create a build directory and move into it.
+
+   ```
+   mkdir .build
+   cd .build
+   ```
+
+   You can use any directory name. Conan treats your working directory as an
+   install folder and generates files with implementation details.
+   You don't need to worry about these files, but make sure to change
+   your working directory to your build directory before calling Conan.
+
+   **Note:** You can specify a directory for the installation files by adding
+   the `install-folder` or `-if` option to every `conan install` command
+   in the next step.
+
+2. Use conan to generate CMake files for every configuration you want to build:
+
+   ```
+   conan install .. --output-folder . --build missing --settings build_type=Release
+   conan install .. --output-folder . --build missing --settings build_type=Debug
+   ```
+
+   To build Debug, in the next step, be sure to set `-DCMAKE_BUILD_TYPE=Debug`
+
+   For a single-configuration generator, e.g. `Unix Makefiles` or `Ninja`,
+   you only need to run this command once.
+   For a multi-configuration generator, e.g. `Visual Studio`, you may want to
+   run it more than once.
+
+   Each of these commands should also have a different `build_type` setting.
+   A second command with the same `build_type` setting will overwrite the files
+   generated by the first. You can pass the build type on the command line with
+   `--settings build_type=$BUILD_TYPE` or in the profile itself,
+   under the section `[settings]` with the key `build_type`.
+
+3. Configure CMake and pass the toolchain file generated by Conan, located at
+   `$OUTPUT_FOLDER/build/generators/conan_toolchain.cmake`.
+
+   Single-config generators:
+
+   Pass the CMake variable [`CMAKE_BUILD_TYPE`][build_type]
+   and make sure it matches the one of the `build_type` settings
+   you chose in the previous step.
+
+   For example, to build Debug, in the next command, replace "Release" with "Debug"
+
+   ```
+   cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release -Dxrpld=ON -Dtests=ON ..
+   ```
+
+   Multi-config generators:
+
+   ```
+   cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -Dxrpld=ON -Dtests=ON  ..
+   ```
+
+   **Note:** You can pass build options for `xrpld` in this step.
+
+4. Build `xrpld`.
+
+   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 xrpld.
+
+   Single-config generators:
+
+   ```
+   ./xrpld --unittest --unittest-jobs N
+   ```
+
+   Multi-config generators:
+
+   ```
+   ./Release/xrpld --unittest --unittest-jobs N
+   ./Debug/xrpld --unittest --unittest-jobs N
+   ```
+
+   Replace the `--unittest-jobs` parameter N with the desired unit tests
+   concurrency. Recommended setting is half of the number of available CPU
+   cores.
+
+   The location of `xrpld` binary in your build directory depends on your
+   CMake generator. Pass `--help` to see the rest of the command line options.
+
+## Code generation
+
+The protocol wrapper classes in `include/xrpl/protocol_autogen/` are generated
+from macro definition files in `include/xrpl/protocol/detail/`. If you modify
+the macro files (e.g. `transactions.macro`, `ledger_entries.macro`) or the
+generation scripts/templates in `cmake/scripts/codegen/`, you need to regenerate the
+files:
+
+```
+cmake --build . --target setup_code_gen  # create venv and install dependencies (once)
+cmake --build . --target code_gen        # regenerate code
+```
+
+The regenerated files should be committed alongside your changes.
+
+## 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. `xrpld` binary built with instrumentation data, enabled by the `coverage`
+   option mentioned above
+2. completed one or more run of the 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 last step of the above is automated into a single target `coverage`. The instrumented
+`xrpld` 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 data). Since `xrpld` binary is simply a dependency of the
+coverage report target, it is possible to re-run the `coverage` target without
+rebuilding the `xrpld` binary. Note, running of the unit tests before the `coverage`
+target is left to the developer. Each such run will append to the coverage data
+collected in the build directory.
+
+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.
+
+Example use with some cmake variables set:
+
+```
+cd .build
+conan install .. --output-folder . --build missing --settings build_type=Debug
+cmake -DCMAKE_BUILD_TYPE=Debug -Dcoverage=ON -Dxrpld=ON -Dtests=ON -Dcoverage_test_parallelism=2 -Dcoverage_format=html-details -Dcoverage_extra_args="--json coverage.json" -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
+cmake --build . --target coverage
+```
+
+After the `coverage` target is completed, the generated coverage report will be
+stored inside the build directory, as either of:
+
+- file named `coverage.`_extension_, with a suitable extension for the report format, or
+- directory named `coverage`, with the `index.html` and other files inside, for the `html-details` or `html-nested` report formats.
+
+## Sanitizers
+
+To build dependencies and xrpld with sanitizer instrumentation, set the
+`SANITIZERS` environment variable when running `conan install` and use the `sanitizers` profile:
+
+```bash
+export SANITIZERS=address,undefinedbehavior
+
+conan install .. --output-folder . --profile:all sanitizers --build missing --settings build_type=Debug
+```
+
+You can then build and test as usual, with the generated `xrpld` binary containing the sanitizer instrumentation. When you run it, it will report any sanitizer errors it detects in the console output.
+
+See [Sanitizers docs](./docs/build/sanitizers.md) for more details.
+
+## Options
+
+| Option     | Default Value | Description                                                    |
+| ---------- | ------------- | -------------------------------------------------------------- |
+| `assert`   | OFF           | Enable assertions.                                             |
+| `coverage` | OFF           | Prepare the coverage report.                                   |
+| `tests`    | OFF           | Build tests.                                                   |
+| `unity`    | OFF           | Configure a unity build.                                       |
+| `xrpld`    | OFF           | Build the xrpld application, and not just the libxrpl library. |
+| `werr`     | OFF           | Treat compilation warnings as errors                           |
+| `wextra`   | OFF           | Enable additional compilation warnings                         |
+
+[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 individual libraries from the Conan cache, e.g.
+
+   ```bash
+   conan remove 'grpc/*'
+   ```
+
+   **or**
+
+   Remove all libraries from Conan cache:
+
+   ```bash
+   conan remove '*'
+   ```
+
+3. Re-run [conan export](#patched-recipes) if needed.
+4. [Regenerate lockfile](#conan-lockfile).
+5. Re-run [conan install](#build-and-test).
+
+#### ERROR: Package not resolved
+
+If you're seeing an error like `ERROR: Package 'snappy/1.1.10' not resolved: Unable to find 'snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1756234314.246' in remotes.`,
+please add `xrplf` remote or re-run `conan export` for [patched recipes](#patched-recipes).
+
+### `protobuf/port_def.inc` file not found
+
+If `cmake --build .` results in an error due to a missing a protobuf file, then
+you might have generated CMake files for a different `build_type` than the
+`CMAKE_BUILD_TYPE` you passed to Conan.
+
+```
+/xrpld/.build/pb-xrpl.libpb/xrpl/proto/xrpl.pb.h:10:10: fatal error: 'google/protobuf/port_def.inc' file not found
+   10 | #include <google/protobuf/port_def.inc>
+      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+1 error generated.
+```
+
+For example, if you want to build Debug:
+
+1. For conan install, pass `--settings build_type=Debug`
+2. For cmake, pass `-DCMAKE_BUILD_TYPE=Debug`
+
+## 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 `xrpl_libs`
+     (search for the existing call to `target_link_libraries(xrpl_libs INTERFACE ...)`).
+4. Start coding! Don't forget to include whatever headers you need from the package.
+
+[1]: https://github.com/conan-io/conan-center-index/issues/13168
+[2]: https://en.cppreference.com/w/cpp/compiler_support/20
+[3]: https://docs.conan.io/en/latest/getting_started.html
+[5]: https://en.wikipedia.org/wiki/Unity_build
+[6]: https://github.com/boostorg/beast/issues/2648
+[7]: https://github.com/boostorg/beast/issues/2661
+[gcovr]: https://gcovr.com/en/stable/getting-started.html
+[python-pip]: https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/
+[build_type]: https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
+[profile]: https://docs.conan.io/en/latest/reference/profiles.html

Builds/CMake/CMakeFuncs.cmake

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

Builds/CMake/Findjemalloc.cmake

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

Builds/Test.py

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

Builds/VisualStudio2017/CMakeSettings-example.json

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

Builds/VisualStudio2017/README.md

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

Builds/build_all.sh

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

Builds/linux/README.md

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

Builds/macos/README.md

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

CMakeLists.txt

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

Jenkinsfile

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

LICENSE

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

LICENSE.md

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

README.md

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

SCOPE_OF_WORK.md

@@ -0,0 +1,395 @@
+# XRPLD Automated Documentation System — Scope of Work
+
+## 1. Problem Statement
+
+The XRP Ledger daemon (`xrpld`) is a ~275,000 line C++ codebase with 1,183
+source files across the core library, protocol layer, and application server.
+It is the single implementation of the XRP Ledger protocol and processes
+billions of dollars in value.
+
+Despite this criticality, the codebase has minimal inline documentation. Only
+569 of 1,183 files contain any Doxygen-style doc comments, and most of those
+are sparse — a class-level sentence or two, rarely covering individual methods,
+parameters, or behavioral invariants.
+
+The only formal documentation effort — an external specification by Common
+Prefix — has fundamental structural problems:
+
+- **Drift is the default state.** The spec lives in a separate repository
+  with no CI linkage to the codebase. Every commit to `rippled` that changes
+  behavior silently invalidates the spec. Even one week of drift makes
+  the spec unreliable.
+- **Separate repo, separate context.** No contributor has both repos open.
+  When a bug comes in, the developer reads the code, not the spec. A
+  recent bug would have been caught if the code itself was documented.
+- **No code-level documentation.** The spec describes system-level behavior
+  (payment engine, DEX) but does not document individual functions, classes,
+  parameters, or invariants. A developer working on a specific function
+  gets no help.
+- **Vendor dependency.** Ripple has a critical documentation dependency on a
+  single external firm. If the contract ends, the spec orphans.
+- **Perverse incentive.** The vendor profits from complexity and drift.
+  Cleaner code and better inline docs reduce the need for external
+  specification work.
+
+## 2. Solution as Built
+
+An automated, in-repo documentation system with five components, all living
+alongside the code with no external repos and no external vendor dependency:
+
+1. **Module skills** — Per-module knowledge files in [docs/skills/](docs/skills/)
+   that capture the "soul" of each subsystem (key files, patterns, pitfalls,
+   invariants). These are the durable, human-maintained context that the
+   automated agent and human contributors both consult.
+2. **doc-agent (Claude Agent SDK app)** — A TypeScript tool at
+   [.github/scripts/doc-agent/](.github/scripts/doc-agent/) with three modes:
+   `document` (write Doxygen comments), `review` (detect drift on a diff),
+   and `regen-skills` (rebuild a skill file from current code).
+3. **Doc-review GitHub Action** — Runs the review mode on every PR; posts
+   inline comments and a sticky summary. Currently warning-only.
+4. **Coverage enforcement** — CI-enforced documentation coverage thresholds
+   that ratchet up over time, preventing regression.
+5. **Developer slash commands** — Claude Code commands in
+   [.claude/commands/](.claude/commands/) for onboarding, architecture
+   questions, doc review, and bug pattern detection.
+
+Documentation accuracy is enforced by CI the same way code style and test
+coverage are enforced today.
+
+## 3. Deliverables — Built
+
+### 3.1 Documentation Standards
+
+[docs/DOCUMENTATION_STANDARDS.md](docs/DOCUMENTATION_STANDARDS.md) — canonical
+format guide defining:
+- Javadoc-style `/** ... */` Doxygen comments (matches existing convention)
+- Documentation levels: file, class, public method, free function, enum
+- Required Doxygen tags: `@param`, `@return`, `@note`, `@invariant`
+- Quality rules: document behavior and invariants, never paraphrase
+  signatures, terse style (2–5 lines for classes, 1–3 for functions)
+
+### 3.2 Doxygen Configuration Changes
+
+[docs/Doxyfile](docs/Doxyfile):
+- `EXTRACT_ALL = NO` (was `YES`) — undocumented entities are flagged rather
+  than silently extracted
+- `GENERATE_XML = YES` (was `NO`) — required for coverxygen to parse and
+  measure documentation coverage
+
+### 3.3 Module Skills
+
+Thirteen module-level skill files in [docs/skills/](docs/skills/), each one
+a self-contained guide to a subsystem's responsibilities, key types, control
+flow, conventions, and common pitfalls:
+
+| Skill | Covers |
+|-------|--------|
+| [consensus.md](docs/skills/consensus.md) | XRPL consensus algorithm + RCL adapters |
+| [cryptography.md](docs/skills/cryptography.md) | CSPRNG, secure erasure, key handling |
+| [ledger.md](docs/skills/ledger.md) | ReadView/ApplyView, state tables, sandbox |
+| [nodestore.md](docs/skills/nodestore.md) | RocksDB/NuDB/Memory backends |
+| [peering.md](docs/skills/peering.md) | Overlay + peerfinder |
+| [protocol.md](docs/skills/protocol.md) | STObject, SField, Serializer, TER, Keylets |
+| [rpc.md](docs/skills/rpc.md) | RPC handler conventions |
+| [shamap.md](docs/skills/shamap.md) | SHA-256 Merkle radix tree |
+| [sql.md](docs/skills/sql.md) | SOCI database wrapper, checkpointing |
+| [test.md](docs/skills/test.md) | Beast unit test framework conventions |
+| [transactors.md](docs/skills/transactors.md) | Full transactor template |
+| [websockets.md](docs/skills/websockets.md) | WS subscriptions/streams |
+| [index.md](docs/skills/index.md) | Top-level codebase map |
+
+These skills serve a dual purpose: they are reference docs for human
+contributors, and they are injected as system-prompt context by the
+doc-agent (mapping in [src/config.ts](.github/scripts/doc-agent/src/config.ts)).
+
+[install-skills.sh](.github/scripts/doc-agent/install-skills.sh) installs
+the same files as Claude Code skills under `.claude/skills/<name>/SKILL.md`,
+so any Claude Code session in the repo picks them up automatically.
+
+### 3.4 doc-agent (Claude Agent SDK)
+
+A TypeScript application at [.github/scripts/doc-agent/](.github/scripts/doc-agent/),
+built on `@anthropic-ai/claude-agent-sdk`. Three modes:
+
+| Mode | Purpose |
+|------|---------|
+| `document` | Add Doxygen comments to a file or directory. Reads sibling `<file>.ai.md` context, the module skill, and the source file; uses `permissionMode: 'acceptEdits'` to write directly. |
+| `review` | Given a git range or PR number, detect doc drift. Emits `doc-review-report.md` (sticky comment) and `doc-review-comments.json` (inline comments). |
+| `regen-skills` | Rebuild a module's skill file at `docs/skills/<module>.md` from the module's `.ai.md` files plus existing skill content. |
+
+Layout:
+
+```
+doc-agent/
+├── package.json          # Node >= 20.12, @anthropic-ai/claude-agent-sdk
+├── biome.json            # lint + format
+├── install-skills.sh     # copies docs/skills/*.md → .claude/skills/*/SKILL.md
+├── prompts/              # System prompts as markdown (editable without code changes)
+│   ├── document-file.md
+│   ├── review-diff.md
+│   └── regen-skill.md
+└── src/
+    ├── index.ts          # CLI entry (document | review | regen-skills)
+    ├── config.ts         # Paths, model, MODULE_SKILL_MAP
+    ├── prompt-loader.ts  # Loads prompts + injects module skill
+    ├── document.ts
+    ├── review.ts
+    ├── regen-skills.ts
+    └── types.ts
+```
+
+Notable design decisions:
+- **Prompts as markdown, not strings.** Operators tune prompts without
+  touching TypeScript or redeploying.
+- **`.ai.md` sidecar input.** When documenting a file, the agent reads a
+  sibling `<file>.ai.md` (high-signal prose generated upstream by the
+  `athenah-ai` pipeline) as the authoritative source of intent. These are
+  gitignored (`*.ai.md` in [.gitignore](.gitignore)) and discarded once
+  the initial pass is complete.
+- **Model selection via env.** `DOC_AGENT_MODEL` env var; default
+  `claude-sonnet-4-6`.
+- **Repo root override.** `XRPLD_ROOT` env var allows running the agent
+  against a different checkout (useful in CI and local testing).
+
+### 3.5 Documentation Coverage Pipeline
+
+| File | Purpose |
+|------|---------|
+| [.github/doc-coverage-thresholds.json](.github/doc-coverage-thresholds.json) | Per-module thresholds + quarterly ratchet schedule |
+| [.github/scripts/doc-coverage-check.py](.github/scripts/doc-coverage-check.py) | Parses coverxygen LCOV, checks thresholds, generates PR report |
+| [.github/workflows/doc-coverage.yml](.github/workflows/doc-coverage.yml) | CI workflow: builds Doxygen XML, runs coverxygen, posts coverage to PR |
+| [cmake/XrplDocs.cmake](cmake/XrplDocs.cmake) | `docs` CMake target wiring |
+
+Flow:
+1. On every PR touching C++ files, the workflow builds Doxygen XML for
+   both the PR branch and the base branch (using
+   `ghcr.io/xrplf/ci/tools-rippled-documentation`).
+2. Coverxygen generates LCOV-format coverage from the XML.
+3. The check script compares coverage against per-module thresholds.
+4. Ratchet mode (`no_decrease`) prevents any PR from reducing coverage.
+5. New files added in a PR require ≥ 80% doc coverage.
+6. Results are posted as a sticky PR comment with per-module breakdown.
+
+### 3.6 Doc-Review GitHub Action
+
+| File | Purpose |
+|------|---------|
+| [.github/workflows/doc-review.yml](.github/workflows/doc-review.yml) | CI workflow: runs on PR, posts review |
+
+The workflow invokes the doc-agent `review` mode (Section 3.4) directly —
+there is no separate CI script. The same code path serves CI and local use,
+so prompt and logic changes are tested in one place.
+
+Flow:
+1. On every PR, the workflow runs `npm run review -- "$BASE..$HEAD"` in the
+   doc-agent directory.
+2. doc-agent enumerates C++ files changed in the range, extracts diff
+   hunks plus existing doc comments, and asks Claude per file whether the
+   docs are still accurate.
+3. Outputs `doc-review-report.md` (sticky PR comment) and
+   `doc-review-comments.json` (inline review comments via
+   `actions/github-script`).
+4. Runs in **warning-only mode** — does not block merge.
+
+Local invocation uses the same command:
+`npm run review develop..HEAD` or `npm run review -- --pr 1234`.
+
+Cost: only changed files and changed hunks within those files are
+processed. Estimated ~$0.05–0.15 per PR.
+
+### 3.7 Claude Code Slash Commands
+
+Four developer-facing commands in [.claude/commands/](.claude/commands/):
+
+| Command | Purpose |
+|---------|---------|
+| [doc-review](.claude/commands/doc-review.md) | Review doc accuracy for files changed on current branch |
+| [explain-module](.claude/commands/explain-module.md) | Explain a module's architecture, classes, control flow, entry points |
+| [how-does-x-work](.claude/commands/how-does-x-work.md) | Trace a feature through the codebase with file/line references |
+| [find-bug-patterns](.claude/commands/find-bug-patterns.md) | Scan code for common xrpld bug patterns (unchecked TER, integer overflow, missing amendment gates, etc.) |
+
+### 3.8 Full Codebase Documentation
+
+The initial documentation pass covers 1,183 C++ files organized into 21
+module-level PRs (see Section 5). The doc-agent `document` mode produces
+each PR in parallel across modules; each file's output is then
+domain-expert reviewed before merge.
+
+## 4. Resources Required
+
+### 4.1 People
+
+| Role | Responsibility |
+|------|---------------|
+| **Documentation lead** | Runs `doc-agent document` per module, reviews output, submits PRs, iterates on prompts in [prompts/](.github/scripts/doc-agent/prompts/) |
+| **Domain reviewers** (rotating) | Review doc PRs for semantic accuracy in their area of expertise |
+| **CI/infrastructure** | Deploys workflows, monitors costs, tunes false-positive rate on doc-review action |
+
+### 4.2 Infrastructure & Tools
+
+| Resource | Purpose |
+|----------|---------|
+| **Anthropic API access** | Powers the doc-agent (`document`, `review`, `regen-skills`) and the doc-review GitHub Action |
+| **Claude Agent SDK** | `@anthropic-ai/claude-agent-sdk` Node package |
+| **Node.js >= 20.12** | Native `--env-file` support; runs the doc-agent |
+| **GitHub Actions minutes** | Doc-coverage workflow (Doxygen XML build + coverxygen) and doc-review workflow |
+| **Coverxygen** | Python package, open source (MIT) |
+| **Doxygen** | Already configured — uses existing `ghcr.io/xrplf/ci/tools-rippled-documentation` container |
+| **GitHub Actions secret** | `ANTHROPIC_API_KEY` — for doc-review workflow |
+| **athenah-ai pipeline output** | Generates `.ai.md` sidecar context files consumed by `doc-agent document`; gitignored, removed post-pass |
+
+### 4.3 Access & Permissions
+
+- Write access to the `rippled` repository (or a fork for initial PRs)
+- Ability to add GitHub Actions secrets (`ANTHROPIC_API_KEY`)
+- Ability to modify required status checks (when promoting doc-review from
+  warning to required)
+
+## 5. Execution Plan
+
+Module passes run in parallel — the doc-agent operates per-module
+independently, so foundation, protocol, and application layers are
+generated concurrently rather than sequentially. Module groupings below
+reflect dependency layering for review purposes, not a serial schedule.
+
+### Phase 0: Infrastructure — Complete
+
+Tooling shipped as the foundation PR:
+
+- [x] [docs/DOCUMENTATION_STANDARDS.md](docs/DOCUMENTATION_STANDARDS.md)
+- [x] [docs/Doxyfile](docs/Doxyfile) modifications
+- [x] [docs/skills/](docs/skills/) — 13 module skills + index
+- [x] [.github/scripts/doc-agent/](.github/scripts/doc-agent/) — Agent SDK app (document / review / regen-skills)
+- [x] [.github/scripts/doc-agent/install-skills.sh](.github/scripts/doc-agent/install-skills.sh)
+- [x] [.github/doc-coverage-thresholds.json](.github/doc-coverage-thresholds.json)
+- [x] [.github/scripts/doc-coverage-check.py](.github/scripts/doc-coverage-check.py)
+- [x] [.github/workflows/doc-coverage.yml](.github/workflows/doc-coverage.yml)
+- [x] [cmake/XrplDocs.cmake](cmake/XrplDocs.cmake)
+- [x] [.github/workflows/doc-review.yml](.github/workflows/doc-review.yml) — invokes doc-agent `review` mode directly
+- [x] [.claude/commands/](.claude/commands/) — 4 developer slash commands
+
+**Exit criteria met:** All workflows pass on a test PR. Coverage report
+renders correctly. Doc-review action posts comments without false positives
+on a sample PR.
+
+### Phase 1: Foundation Modules
+
+Lowest-level modules — everything else depends on these:
+
+| PR | Module | ~Files | ~Lines |
+|----|--------|--------|--------|
+| 1 | `include/xrpl/basics/` + `src/libxrpl/basics/` | 63 | ~15K |
+| 2 | `include/xrpl/crypto/` + `src/libxrpl/crypto/` | 6 | ~1.5K |
+| 3 | `include/xrpl/json/` + `src/libxrpl/json/` | 18 | ~4K |
+| 4 | `include/xrpl/beast/` + `src/libxrpl/beast/` | 88 | ~20K |
+
+**Process per PR:**
+1. Create branch `docs/module-<name>` from `develop`.
+2. Run `npm run document <path>` from `.github/scripts/doc-agent/`. The
+   agent reads each file's `.ai.md` sidecar, the matching module skill,
+   and the file itself, then writes Doxygen comments per the standards.
+3. Domain expert reviews for semantic accuracy.
+4. Run Doxygen build to validate no doc errors.
+5. Merge; ratchet that module's threshold up to actual coverage level.
+
+### Phase 2: Protocol & Transaction Engine
+
+| PR | Module | ~Files |
+|----|--------|--------|
+| 5 | `include/xrpl/protocol/` + `src/libxrpl/protocol/` | 150 |
+| 6 | `include/xrpl/ledger/` + `src/libxrpl/ledger/` | 68 |
+| 7 | `include/xrpl/conditions/` + `src/libxrpl/conditions/` | 8 |
+| 8 | `include/xrpl/tx/` (core framework: Transactor, ApplyContext) | 15 |
+| 9 | Payment transactors | 9 |
+| 10 | DEX/AMM transactors | 25 |
+| 11 | Escrow transactors | 7 |
+| 12 | Other transactors (NFT, token, vault, check, etc.) | 60 |
+| 13 | Pathfinding + invariants | 30 |
+
+### Phase 3: Server & Application Layer
+
+| PR | Module | ~Files |
+|----|--------|--------|
+| 14 | `include/xrpl/server/` + `src/libxrpl/server/` | 35 |
+| 15 | `include/xrpl/nodestore/` + `src/libxrpl/nodestore/` | 30 |
+| 16 | SHAMap | 25 |
+| 17 | Resource management | 17 |
+| 18 | Overlay + peerfinder | 56 |
+| 19 | Consensus | 15 |
+| 20 | Application core (ledger, main, misc, rdb) | 133 |
+| 21 | RPC handlers | 131 |
+
+Once Phases 1–3 are merged, the doc-review action is promoted from
+warning to a **required check**.
+
+### Phase 4: Tests & Polish
+
+- Document test files (brief docs only — test name + what it validates)
+- Remove `.ai.md` sidecar files (they were transitional input only)
+- Retrospective: false-positive rate, API costs, contributor feedback
+
+## 6. Coverage Threshold Ratchet
+
+Coverage thresholds are enforced per-module via
+[.github/doc-coverage-thresholds.json](.github/doc-coverage-thresholds.json):
+
+- **`no_decrease` ratchet** — no PR may reduce coverage on a module
+  below its current level.
+- **New files** require ≥ 80% doc coverage regardless of module threshold.
+- **Per-module floors** are raised manually as each module's PR lands,
+  pinning the achieved coverage as the new floor.
+
+There is no calendar-based ratchet; thresholds advance with the work.
+
+## 7. Risk Assessment
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| LLM generates plausible but wrong docs | Medium | High | Every doc PR requires human domain expert review. `.ai.md` sidecars (athenah-ai) ground the agent in source-derived intent rather than free generation. |
+| Doc-review action false positives annoy contributors | Medium | Medium | Warning-only mode initially. Promote to required only when FP rate < 5%. Prompts live in markdown ([prompts/](.github/scripts/doc-agent/prompts/)) and can be tuned without a code release. |
+| Coverage enforcement blocks unrelated PRs | Low | Medium | `no_decrease` ratchet only; per-module floors raised manually as modules land. |
+| Reviewer bandwidth bottleneck | Medium | Medium | PRs scoped to single modules. Reviewers rotate. |
+| API costs exceed budget | Low | Low | Only diff hunks processed. Monthly budget cap with alerting. |
+| Doxygen XML build adds CI time | Low | Low | Runs in parallel with existing checks. Uses existing documentation container. |
+| Doc comments add code noise | Low | Low | Terse style enforced by standards. 2–5 lines per class, 1–3 per function. |
+| Skill files drift from code | Medium | Medium | `doc-agent regen-skills <module>` rebuilds a skill from current `.ai.md` files; intended to be run periodically. |
+
+## 8. Success Metrics
+
+| Metric | Measurement |
+|--------|-------------|
+| Documentation coverage (public API) | Coverxygen LCOV reports in CI |
+| Doc drift catch rate | Sample audit of merged PRs vs doc-review output |
+| False positive rate (doc-review action) | Track dismissed vs accepted suggestions |
+| Spec-vs-code contradictions | Bug reports citing wrong documentation |
+| Contributor satisfaction | Periodic survey: "docs helped me understand the code" |
+| Onboarding time | Measure across new contributors before/after |
+| API cost | Anthropic API billing dashboard |
+
+## 9. What This Replaces
+
+This system does **not** replace the Common Prefix formal verification
+work directly — formal verification and code documentation solve different
+problems. However, it eliminates the need for an external specification as
+the "source of truth" for how xrpld behaves:
+
+| Need | Before | After |
+|------|--------|-------|
+| "What does this function do?" | Read the code, guess | Read the inline Doxygen doc |
+| "How does the payment engine work?" | Read Common Prefix spec (maybe stale) | Read [docs/skills/transactors.md](docs/skills/transactors.md) or run `/explain-module` |
+| "Did this PR break any documented behavior?" | Manual review, hope someone notices | Doc-review action flags it automatically |
+| "What's our documentation coverage?" | Unknown | Measured per-module in every PR |
+| "Is the spec up to date?" | Check manually, probably not | Docs are in-repo, enforced by CI |
+| "Where do I start in module X?" | Ask in chat | Read the module skill in [docs/skills/](docs/skills/) |
+
+## 10. Out of Scope
+
+- **Formal verification.** This project documents code behavior; it does
+  not prove correctness. Formal verification is a separate discipline.
+- **External-facing API documentation.** This covers the C++ source code,
+  not the JSON-RPC API documentation on xrpl.org.
+- **Test coverage.** Test file documentation is brief and optional. Test
+  coverage measurement is handled by existing Codecov integration.
+- **Architectural decision records.** Module-level READMEs already exist
+  for key subsystems. This project adds function/class-level docs and the
+  module skills layer, not system-level ADRs.