Merge branch 'pratik/otel-phase9-metric-gap-fill' into pratik/otel-phase10-workload-validation

develop's new fix-gtest-names pre-commit hook requires a snake_case test-case
name. CI runs it with --all-files, so the existing CamelCase names fail the
check on every branch that carries these files.

.clang-format

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

.clang-tidy

@@ -0,0 +1,126 @@
+---
+Checks: "-*,
+  bugprone-*,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-exception-escape,
+  -bugprone-implicit-widening-of-multiplication-result,
+  -bugprone-narrowing-conversions,
+  -bugprone-throwing-static-initialization,
+
+  cppcoreguidelines-*,
+  -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-avoid-const-or-ref-data-members,
+  -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-c-copy-assignment-signature,
+  -cppcoreguidelines-interfaces-global-init,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-missing-std-forward,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-noexcept-move-operations,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-union-access,
+  -cppcoreguidelines-special-member-functions,
+
+  llvm-namespace-comment,
+
+  misc-*,
+  -misc-multiple-inheritance,
+  -misc-no-recursion,
+  -misc-non-private-member-variables-in-classes,
+  -misc-override-with-different-visibility,
+  -misc-unused-parameters,
+  -misc-use-anonymous-namespace,
+  -misc-use-internal-linkage,
+
+  modernize-*,
+  -modernize-avoid-c-arrays,
+  -modernize-avoid-c-style-cast,
+  -modernize-return-braced-init-list,
+  -modernize-use-integer-sign-comparison,
+  -modernize-use-trailing-return-type,
+
+  performance-*,
+  -performance-avoid-endl,
+  -performance-enum-size,
+  -performance-noexcept-move-constructor,
+  -performance-unnecessary-copy-initialization,
+  -performance-unnecessary-value-param,
+
+  readability-*,
+  -readability-avoid-const-params-in-decls,
+  -readability-container-data-pointer,
+  -readability-function-cognitive-complexity,
+  -readability-identifier-length,
+  -readability-inconsistent-declaration-parameter-name,
+  -readability-isolate-declaration,
+  -readability-magic-numbers,
+  -readability-named-parameter,
+  -readability-qualified-auto,
+  -readability-redundant-access-specifiers,
+  -readability-static-accessed-through-instance,
+  -readability-uppercase-literal-suffix
+  "
+# ---
+# bugprone-narrowing-conversions,                      # This will break a lot of code but we should enable it in the future because it can eliminate a lot of bugs
+# misc-override-with-different-visibility,             # Will be addressed in a future PR, but for now it generates too many warnings
+# 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
+# ---
+
+FormatStyle: file
+
+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/.*;openssl/obj_mac\\.h"
+
+  readability-braces-around-statements.ShortStatementLines: 2
+  readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
+  readability-identifier-naming.NamespaceCase: lower_case
+  readability-identifier-naming.InlineNamespaceCase: lower_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: CamelCase
+  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: CamelCase
+  readability-identifier-naming.ClassConstantPrefix: "k"
+  readability-identifier-naming.StaticConstantCase: CamelCase
+  readability-identifier-naming.StaticConstantPrefix: "k"
+  readability-identifier-naming.StaticVariableCase: camelBack
+  readability-identifier-naming.ConstexprVariableCase: camelBack
+  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.PrivateMemberCase: camelBack
+  readability-identifier-naming.PrivateMemberSuffix: _
+  readability-identifier-naming.ProtectedMemberCase: camelBack
+  readability-identifier-naming.ProtectedMemberSuffix: _
+  readability-identifier-naming.PublicMemberCase: camelBack
+  readability-identifier-naming.PublicMemberSuffix: ""
+  readability-identifier-naming.GlobalFunctionIgnoredRegexp: "^(to_string|hash_append|tuple_hash)$"
+
+HeaderFilterRegex: '^.*/(tests?|xrpl|xrpld)/.*\.(h|hpp|ipp)$'
+ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$'
+WarningsAsErrors: "*"

.codecov.yml

@@ -1,10 +1,32 @@
 codecov:
   require_ci_to_pass: true
+  # The C++ and Rust uploads land minutes apart; without this gate Codecov
+  # publishes a near-zero total from whichever one arrives first.
+  notify:
+    after_n_builds: 2
+    wait_for_ci: true
 
 comment:
   behavior: default
   layout: reach,diff,flags,tree,reach
-  show_carryforward_flags: false
+  show_carryforward_flags: true
+  after_n_builds: 2
+
+# C++ and Rust coverage upload from independent workflows under the `cpp` and
+# `rust` flags; carryforward keeps one language's total when only the other reran.
+flag_management:
+  default_rules:
+    carryforward: true
+  individual_flags:
+    - name: cpp
+      carryforward: true
+      paths:
+        - include/
+        - src/
+    - name: rust
+      carryforward: true
+      paths:
+        - crates/
 
 coverage:
   range: "70..85"
@@ -27,11 +49,26 @@ github_checks:
 parsers:
   cobertura:
     partials_as_hits: true
-    handle_missing_conditions : true
+    handle_missing_conditions: true
 
 slack_app: false
 
 ignore:
   - "src/test/"
+  - "src/tests/"
   - "include/xrpl/beast/test/"
   - "include/xrpl/beast/unit_test/"
+  # Telemetry modules. Telemetry compiles in by default (conanfile.py,
+  # CMakeLists.txt), but the unit-test suite never starts an exporter, so these
+  # files record no coverage. This block belongs on the earliest branch that
+  # adds telemetry code — codecov config only flows child-ward, so an ignore
+  # added on a later branch can never cover the branches before it.
+  - "src/xrpld/telemetry/"
+  - "src/libxrpl/telemetry/"
+  - "include/xrpl/telemetry/"
+  - "src/libxrpl/beast/insight/OTelCollector.cpp"
+  - "include/xrpl/beast/insight/OTelCollector.h"
+  # Per-module span-name and span-label constant headers: compile-time
+  # constants only, colocated with their subsystem rather than under telemetry/.
+  - "**/*SpanNames.h"
+  - "**/*SpanLabels.h"

.cspell.config.yaml

@@ -0,0 +1,432 @@
+ignorePaths:
+  - build/**
+  - src/libxrpl/crypto
+  - CMakeUserPresets.json
+  - Doxyfile
+  - docs/**/*.puml
+  - cmake/**
+  - LICENSE.md
+  - .clang-tidy
+  - nix/check-tools/*.txt # generated, and full of Nix store hashes
+language: en
+allowCompoundWords: true # TODO (#6334)
+ignoreRandomStrings: true
+minWordLength: 5
+dictionaries:
+  - cpp
+  - en_US
+  - en_GB
+ignoreRegExpList:
+  - /\b[rs][1-9A-HJ-NP-Za-km-z]{25,34}/g # addresses and seeds
+  - /\bC[A-Z0-9]{15}/g # CTIDs
+  - /\b(XRPL|BEAST)_[A-Z_0-9]+_H_INCLUDED+/g # include guards
+  - /\b(XRPL|BEAST)_[A-Z_0-9]+_H+/g # include guards
+  - /::[a-z:_]+/g # things from other namespaces
+  - /\blib[a-z]+/g # libraries
+  - /\b[0-9]{4}-[0-9]{2}-[0-9]{2}[,:][A-Za-zÀ-ÖØ-öø-ÿ.\s]+/g # copyright dates
+  - /\b[0-9]{4}[,:]?\s*[A-Za-zÀ-ÖØ-öø-ÿ.\s]+/g # copyright years
+  - /\[[A-Za-z0-9-]+\]\(https:\/\/github.com\/[A-Za-z0-9-]+\)/g # Github usernames
+  - /-[DWw][a-zA-Z0-9_-]+=/g # compile flags
+  - /[\['"`]-[DWw][a-zA-Z0-9_-]+['"`\]]/g # compile flags
+  - ABCDEFGHIJKLMNOPQRSTUVWXYZ
+  - ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
+overrides:
+  - filename:
+      - "**/*_test.cpp" # legacy boost.test files
+      - "src/tests/**/*.cpp" # gtest test files
+    ignoreRegExpList:
+      - /"[^"]*"/g # double-quoted strings
+      - /'[^']*'/g # single-quoted strings
+      - /`[^`]*`/g # backtick strings
+suggestWords:
+  - unsynched->unsynced
+  - synched->synced
+  - synch->sync
+words:
+  - abempty
+  - AMMID
+  - AMMMPT
+  - AMMMPToken
+  - AMMMPTokens
+  - AMMXRP
+  - amt
+  - amts
+  - archs
+  - asnode
+  - asynchrony
+  - attestation
+  - authorises
+  - autobridge
+  - autobridged
+  - autobridging
+  - bimap
+  - bindir
+  - blindings
+  - bookdir
+  - Bougalis
+  - bthomee
+  - Britto
+  - Btrfs
+  - Buildx
+  - canonicality
+  - CGNAT
+  - canonicalised
+  - cctools
+  - changespq
+  - checkme
+  - choco
+  - chrono
+  - citardauq
+  - clawback
+  - clawbacks
+  - clippy
+  - cmaketoolchain
+  - coeffs
+  - coldwallet
+  - compr
+  - conanfile
+  - conanrun
+  - confs
+  - connectability
+  - coro
+  - coros
+  - cowid
+  - cpack
+  - cryptocondition
+  - cryptoconditional
+  - cryptoconditions
+  - csprng
+  - ctest
+  - ctid
+  - currenttxhash
+  - daria
+  - dcmake
+  - dearmor
+  - decryptor
+  - dedented
+  - Dedup
+  - dedup
+  - deleteme
+  - demultiplexer
+  - deserializaton
+  - desync
+  - desynced
+  - determ
+  - disablerepo
+  - distro
+  - doxyfile
+  - dsymutil
+  - dthms
+  - dxrpl
+  - elgamal
+  - enabled
+  - enablerepo
+  - endmacro
+  - envrc
+  - EOCFG
+  - exceptioned
+  - EXPECT_STREQ
+  - exfiltration
+  - Falco
+  - fcontext
+  - finalizers
+  - firewalled
+  - fmtdur
+  - fsanitize
+  - funclets
+  - Gamal
+  - gantt
+  - Gantt
+  - gcov
+  - gcovr
+  - ghead
+  - Gnutella
+  - godexsoft
+  - gpgcheck
+  - gpgkey
+  - havetxset
+  - Hinnant
+  - hotwallet
+  - hicpp
+  - htpasswd
+  - hwaddress
+  - hwrap
+  - ifndef
+  - inequation
+  - initialiser
+  - Injectivity
+  - insuf
+  - insuff
+  - invasively
+  - iou
+  - ious
+  - isrdc
+  - isystem
+  - itype
+  - jemalloc
+  - jlog
+  - jmeter
+  - jtnofill
+  - keylet
+  - keylets
+  - keyvadb
+  - kwarg
+  - kwargs
+  - ledgerentry
+  - ledgerhash
+  - ledgerindex
+  - leftw
+  - legleux
+  - levelization
+  - levelized
+  - libpb
+  - libxrpl
+  - llection
+  - LOCALGOOD
+  - logql
+  - logwstream
+  - Lombrozo
+  - lresolv
+  - lseq
+  - lsmf
+  - ltype
+  - mathbunnyru
+  - mcmodel
+  - MEMORYSTATUSEX
+  - Merkle
+  - misprediction
+  - missingok
+  - MPTAMM
+  - mptbalance
+  - MPTDEX
+  - mptflags
+  - mptid
+  - mptissuance
+  - mptissuanceid
+  - mptissue
+  - mptoken
+  - mptokenid
+  - mptokenissuance
+  - mptokens
+  - mpts
+  - mtgox
+  - multisig
+  - multisign
+  - multisigned
+  - Nakamoto
+  - nftid
+  - nftoffer
+  - nftoken
+  - nftokenid
+  - nftokenpages
+  - nftokens
+  - nftpage
+  - nikb
+  - Nikolaos
+  - nixfmt
+  - nixos
+  - nixpkgs
+  - NETOP
+  - NOLINT
+  - NOLINTNEXTLINE
+  - nonxrp
+  - noreplace
+  - noripple
+  - nostd
+  - nostdinc
+  - notifempty
+  - nudb
+  - nullptr
+  - nunl
+  - Nyffenegger
+  - onlatest
+  - ostr
+  - otelc
+  - otelcol
+  - otool
+  - oxalica
+  - pargs
+  - partitioner
+  - paychan
+  - paychans
+  - Pedersen
+  - permdex
+  - perminute
+  - permissioned
+  - pgrep
+  - pkill
+  - pimpl
+  - pointee
+  - populator
+  - pratik
+  - preauth
+  - preauthorization
+  - preauthorize
+  - preauthorizes
+  - preclaim
+  - preun
+  - protobuf
+  - protos
+  - ptrs
+  - pushd
+  - pyenv
+  - pyparsing
+  - qalloc
+  - qbsprofile
+  - queuable
+  - ransitioned
+  - Raphson
+  - rcflags
+  - reparent
+  - replayer
+  - repodata
+  - repomd
+  - reqps
+  - rerandomize
+  - rerandomization
+  - rerandomized
+  - rerandomizes
+  - rerere
+  - retargeted
+  - retargets
+  - retriable
+  - RIPD
+  - ripdtop
+  - rippleci
+  - rippled
+  - ripplerpc
+  - rippletest
+  - RLUSD
+  - rngfill
+  - rocksdb
+  - Rohrs
+  - roundings
+  - rustc
+  - rustfmt
+  - rustup
+  - sahyadri
+  - sanitisation
+  - sanitise
+  - sanitised
+  - sanitiser
+  - sanitising
+  - Satoshi
+  - scons
+  - Schnorr
+  - secp
+  - sendq
+  - seqit
+  - sf
+  - SFIELD
+  - sfields
+  - shamap
+  - shamapitem
+  - shfmt
+  - shlibs
+  - sidechain
+  - SIGGOOD
+  - sle
+  - sles
+  - soci
+  - socidb
+  - Sonatype
+  - speciality
+  - sponsee
+  - sponsees
+  - SRPMS
+  - sslws
+  - statsd
+  - STATSDCOLLECTOR
+  - stissue
+  - stledgerentry
+  - stnum
+  - stobj
+  - stobject
+  - stpath
+  - stpathset
+  - sttx
+  - stvar
+  - stvector
+  - stxchainattestations
+  - summands
+  - superpeer
+  - superpeers
+  - Swatinem
+  - synthesise
+  - takergets
+  - takerpays
+  - ters
+  - TMEndpointv2
+  - toolchain
+  - tparam
+  - traceql
+  - trixie
+  - tx
+  - txid
+  - txids
+  - txjson
+  - txn
+  - txns
+  - txqueue
+  - txs
+  - ubsan
+  - UBSAN
+  - ufdio
+  - umant
+  - unacquired
+  - unambiguity
+  - unauthorizes
+  - unauthorizing
+  - unergonomic
+  - unfetched
+  - unfindable
+  - unflatten
+  - unfund
+  - ungated
+  - unheld
+  - unimpair
+  - unroutable
+  - unscalable
+  - unserviced
+  - unshareable
+  - unshares
+  - unsponsored
+  - unsquelch
+  - unsquelched
+  - unsquelching
+  - unstored
+  - unsuffixed
+  - unvalidated
+  - unveto
+  - unvetoed
+  - upvotes
+  - USDB
+  - utilisation
+  - variadics
+  - venv
+  - vfalco
+  - vinnie
+  - wasmi
+  - werror
+  - wextra
+  - wptr
+  - writeme
+  - wsrch
+  - wthread
+  - xbridge
+  - xchain
+  - xcrun
+  - ximinez
+  - XMACRO
+  - xored
+  - xrpkuwait
+  - xrpl
+  - xrpld
+  - xrplf
+  - xxhash
+  - xxhasher
+  - xychart
+  - zpages
+  - zstdio
+  - ripplex
+  - mseconds

.envrc

@@ -0,0 +1,10 @@
+watch_file nix/*.nix
+
+# Pinned Rust toolchain, read by nix/packages.nix via fromRustupToolchainFile.
+watch_file rust-toolchain.toml
+
+# The dev shell derivation includes all of conan/ (see nix/devshell.nix), so any
+# change in there has to invalidate direnv's cached environment.
+watch_dir conan
+
+use flake

.gersemi/definitions.cmake

@@ -0,0 +1,110 @@
+# 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_benchmark 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(verify_target_headers target headers_dir)
+endfunction()
+
+function(_verify_add_headers target dir)
+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()
+
+function(patch_nix_binary target)
+endfunction()

.gersemirc

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

.git-blame-ignore-revs

@@ -1,13 +1,81 @@
 # This feature requires Git >= 2.24
 # To use it by default in git blame:
 # git config blame.ignoreRevsFile .git-blame-ignore-revs
-50760c693510894ca368e90369b0cc2dabfd07f3
-e2384885f5f630c8f0ffe4bf21a169b433a16858
-241b9ddde9e11beb7480600fd5ed90e1ef109b21
-760f16f56835663d9286bd29294d074de26a7ba6
-0eebe6a5f4246fced516d52b83ec4e7f47373edd
-2189cc950c0cebb89e4e2fa3b2d8817205bf7cef
-b9d007813378ad0ff45660dc07285b823c7e9855
-fe9a5365b8a52d4acc42eb27369247e6f238a4f9
-9a93577314e6a8d4b4a8368cc9d2b15a5d8303e8
+
+# 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/CODEOWNERS

@@ -1,8 +0,0 @@
-# Allow anyone to review any change by default.
-*
-
-# Require the rpc-reviewers team to review changes to the rpc code.
-include/xrpl/protocol/ @xrplf/rpc-reviewers
-src/libxrpl/protocol/ @xrplf/rpc-reviewers
-src/xrpld/rpc/ @xrplf/rpc-reviewers
-src/xrpld/app/misc/ @xrplf/rpc-reviewers

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,31 +1,36 @@
 ---
 name: Bug Report
-about: Create a report to help us improve rippled
-title: "[Title with short description] (Version: [rippled version])"
-labels: ''
-assignees: ''
-
+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 './rippled --version' as the version number-->
+<!-- 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/feature_request.md

@@ -1,21 +1,25 @@
 ---
 name: Feature Request
-about: Suggest a new feature for the rippled project
-title: "[Title with short description] (Version: [rippled version])"
+about: Suggest a new feature for the xrpld project
+title: "[Title with short description] (Version: [xrpld version])"
 labels: Feature Request
-assignees: ''
-
+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,47 @@
+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: |
+        conan install \
+            --profile:all 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/build/action.yml

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

.github/actions/cargo-cache/action.yml

@@ -0,0 +1,39 @@
+name: Use cargo artifacts cache
+description: >
+  Cache the cargo build artifacts with rust-cache. Never caches ~/.cargo/bin:
+  when saving the cache, rust-cache deletes all binaries that were already
+  present there, which on persistent self-hosted runners wipes the tools
+  installed by prepare-runner. Harmless on ephemeral runners, but kept
+  consistent everywhere.
+
+inputs:
+  workspaces:
+    description: "Workspaces to cache, as 'workspace -> target' lines."
+    required: false
+    default: crates
+  key:
+    description: "Additional part of the cache key."
+    required: false
+    default: ""
+  cache-directories:
+    description: "Additional non-workspace directories to cache."
+    required: false
+    default: ""
+  save-if:
+    description: >
+      Condition for saving the cache after the job. Defaults to save only from develop branch
+    required: false
+    default: ${{ github.ref == 'refs/heads/develop' }}
+
+runs:
+  using: composite
+
+  steps:
+    - name: Use cargo artifacts cache
+      uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+      with:
+        cache-bin: "false"
+        cache-directories: ${{ inputs.cache-directories }}
+        key: ${{ inputs.key }}
+        save-if: ${{ inputs.save-if }}
+        workspaces: ${{ inputs.workspaces }}

.github/actions/dependencies/action.yml

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

.github/actions/release-info/action.yml

@@ -0,0 +1,44 @@
+name: Release info
+description: "Derive the version, release channel and package release number for this build."
+
+outputs:
+  version:
+    description: "The build version number."
+    value: ${{ steps.version.outputs.version }}
+  channel:
+    description: "The release channel this build belongs to."
+    value: ${{ steps.release_info.outputs.channel }}
+  pkg_release:
+    description: "The package release number: 1 for a tag, <run number>.<commit date>git<short commit hash> otherwise."
+    value: ${{ steps.release_info.outputs.pkg_release }}
+
+runs:
+  using: composite
+  steps:
+    # A tag names its own version. Anything else takes it from BuildInfo.cpp and
+    # appends the commit hash as build metadata, joined with a plus sign because a
+    # Conan version cannot contain two hyphens.
+    - name: Determine version
+      id: version
+      shell: bash
+      env:
+        IS_TAG: ${{ startsWith(github.ref, 'refs/tags/') }}
+        REF_NAME: ${{ github.ref_name }}
+        SHA: ${{ github.sha }}
+      run: |
+        if [[ "${IS_TAG}" == "true" ]]; then
+            version="${REF_NAME}"
+        else
+            version="$(awk -F'"' '/versionString =/ { print $2 }' src/libxrpl/protocol/BuildInfo.cpp)"
+            if [[ -z "${version}" ]]; then
+                echo "Unable to read versionString from BuildInfo.cpp." >&2
+                exit 1
+            fi
+            version="${version}+${SHA:0:7}"
+        fi
+
+        echo "version=${version}" | tee -a "${GITHUB_OUTPUT}"
+
+    - name: Determine release channel and package release
+      id: release_info
+      uses: XRPLF/actions/release-info@7cc0e4a8d9d0b838f92c48d312856b190341bbba

.github/actions/set-compiler-env/action.yml

@@ -0,0 +1,34 @@
+name: Set compiler environment
+description: "Set CC and CXX environment variables for the given compiler."
+
+inputs:
+  compiler:
+    description: 'The compiler to use ("gcc" or "clang").'
+    required: true
+
+runs:
+  using: composite
+
+  steps:
+    - name: Set CC and CXX for gcc
+      if: ${{ inputs.compiler == 'gcc' }}
+      shell: bash
+      run: |
+        echo "CC=gcc" >>"${GITHUB_ENV}"
+        echo "CXX=g++" >>"${GITHUB_ENV}"
+
+    - name: Set CC and CXX for clang
+      if: ${{ inputs.compiler == 'clang' }}
+      shell: bash
+      run: |
+        echo "CC=clang" >>"${GITHUB_ENV}"
+        echo "CXX=clang++" >>"${GITHUB_ENV}"
+
+    - name: Fail on unknown compiler
+      if: ${{ inputs.compiler != 'gcc' && inputs.compiler != 'clang' }}
+      shell: bash
+      env:
+        COMPILER: ${{ inputs.compiler }}
+      run: |
+        echo "Unknown compiler: $COMPILER" >&2
+        exit 1

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

@@ -0,0 +1,49 @@
+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.xrplf.org/repository/conan/
+
+runs:
+  using: composite
+
+  steps:
+    - name: Apply custom configuration to global.conf
+      shell: bash
+      run: |
+        cat conan/global.conf ${{ runner.os == 'Linux' && '>>' || '>' }} $(conan config home)/global.conf
+
+    - name: Show global configuration
+      shell: bash
+      run: |
+        conan config show '*'
+
+    - name: Install profiles
+      shell: bash
+      run: |
+        conan config install conan/profiles/ -tf $(conan config home)/profiles/
+
+    - name: Show CI profile
+      shell: bash
+      run: |
+        conan profile show --profile ci
+
+    - name: Add a remote
+      shell: bash
+      env:
+        REMOTE_NAME: ${{ inputs.remote_name }}
+        REMOTE_URL: ${{ inputs.remote_url }}
+      run: |
+        conan remote add --index 0 --force "${REMOTE_NAME}" "${REMOTE_URL}"
+
+    - name: List remotes
+      shell: bash
+      run: |
+        conan remote list

.github/actions/setup-nix-env/action.yml

@@ -0,0 +1,70 @@
+name: Setup Nix environment
+description: "Build the flake's CI environment and put its tools on PATH."
+
+# The environment from nix/ci-env.nix, the same one the Linux CI images bake in
+# (see nix/docker). Exported onto PATH rather than entered with `nix develop`:
+# the composite actions below run plain `bash` and would escape a dev shell.
+
+runs:
+  using: composite
+
+  steps:
+    - name: Build the CI environment
+      id: build
+      shell: bash
+      env:
+        # --out-link doubles as a GC root for the length of the job.
+        OUT_LINK: ${{ runner.temp }}/xrpld-ci-env
+      run: |
+        # --extra-experimental-features: flakes may not be on in the runner's nix.conf.
+        nix --extra-experimental-features "nix-command flakes" \
+            build .#default --out-link "${OUT_LINK}" --print-build-logs
+        echo "path=$(readlink -f "${OUT_LINK}")" >>"${GITHUB_OUTPUT}"
+
+    - name: Export the environment
+      shell: bash
+      env:
+        ENV_PATH: ${{ steps.build.outputs.path }}
+      run: |
+        echo "${ENV_PATH}/bin" >>"${GITHUB_PATH}"
+
+        # Already KEY=VALUE per line. See `darwinEnv` in nix/ci-env.nix.
+        ENV_FILE="${ENV_PATH}/share/xrpld-ci-env/env"
+        if [ -f "${ENV_FILE}" ]; then
+            cat "${ENV_FILE}" >>"${GITHUB_ENV}"
+        fi
+
+        # XrplSanity.cmake otherwise rejects a Nix compiler as one that leaked.
+        echo "XRPL_DEVSHELL=ci-env" >>"${GITHUB_ENV}"
+
+        # Unlike the Linux nix images, macOS needs no SSL_CERT_FILE: it has its
+        # own trust store, and pinning would break TLS to hosts relying on it.
+
+        # In RUNNER_TEMP, which the runner empties per job, like the `.conan2`
+        # prepare-runner hands the system toolchain - but under its own name:
+        # that Conan is a different version, and the two would migrate each
+        # other's cache.
+        echo "CONAN_HOME=${RUNNER_TEMP}/.conan2-nix" >>"${GITHUB_ENV}"
+
+    # Config, profiles and remote, exactly as the dev shell sets them up on
+    # entry; the `setup-conan` action is skipped for this toolchain.
+    - name: Setup Conan
+      shell: bash
+      run: ./conan/init.sh
+
+    # `Check tools` runs later but swallows failures; a bad export would just
+    # build with the system toolchain.
+    - name: Verify the toolchain resolves into the Nix store
+      shell: bash
+      run: |
+        for tool in clang clang++ cmake ninja conan; do
+            path="$(command -v "${tool}" || true)"
+            echo "${tool} -> ${path:-<not found>}"
+            case "${path}" in
+                /nix/store/*) ;;
+                *)
+                    echo "::error::${tool} does not resolve into the Nix store"
+                    exit 1
+                    ;;
+            esac
+        done

.github/dependabot.yml

@@ -0,0 +1,38 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directories:
+      - /
+      - .github/actions/build-deps/
+      - .github/actions/cargo-cache/
+      - .github/actions/release-info/
+      - .github/actions/set-compiler-env/
+      - .github/actions/setup-conan/
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "ci: [DEPENDABOT] "
+    target-branch: develop
+    groups:
+      github-actions:
+        patterns:
+          - "*"
+
+  - package-ecosystem: cargo
+    directory: /crates
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "chore: [DEPENDABOT] "
+    target-branch: develop
+    open-pull-requests-limit: 10
+    groups:
+      rust-dependencies:
+        patterns:
+          - "*"

.github/pull_request_template.md

@@ -1,10 +1,10 @@
 <!--
-This PR template helps you to write a good pull request description.
+This PR template helps you 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
+opening the PR. This avoids 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
 -->
@@ -15,10 +15,10 @@ https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-
 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.
+If there is a relevant task or issue, please link it here.
 -->
 
-### Context of Change
+## Context of Change
 
 <!--
 Please include the context of a change.
@@ -29,23 +29,7 @@ If a refactor, how is this better than the previous implementation?
 If there is a spec or design document for this feature, please link it here.
 -->
 
-### Type of Change
-
-<!--
-Please check [x] relevant options, delete irrelevant ones.
--->
-
-- [ ] Bug fix (non-breaking change which fixes an issue)
-- [ ] New feature (non-breaking change which adds functionality)
-- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
-- [ ] Refactor (non-breaking change that only restructures code)
-- [ ] Performance (increase or change in throughput and/or latency)
-- [ ] Tests (you added tests for code that already exists, or your new feature included in this PR)
-- [ ] Documentation update
-- [ ] Chore (no impact to binary, e.g. `.gitignore`, formatting, dropping support for older tooling)
-- [ ] Release
-
-### API Impact
+## API Impact
 
 <!--
 Please check [x] relevant options, delete irrelevant ones.
@@ -81,5 +65,5 @@ This section may not be needed if your change includes thoroughly commented unit
 
 <!--
 ## Future Tasks
-For future tasks related to PR.
+For future tasks related to this 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/format-inline-bash.py

@@ -0,0 +1,403 @@
+#!/usr/bin/env python3
+
+"""
+Format embedded shell snippets using the shfmt hook configured in
+.pre-commit-config.yaml.
+
+Two shapes are recognised:
+
+* YAML workflow/action files: literal block-scalar runs (`run: |`) and
+  single-line runs (`run: some command`). A single-line run is upgraded to
+  a `run: |` block scalar if shfmt's output spans multiple lines.
+
+* Markdown files: ``` ```bash ``` fenced code blocks.
+
+Any block that shfmt cannot parse is skipped with a warning on stderr, so
+the file is left untouched and surrounding blocks still get formatted.
+
+For each occurrence the body is dedented, written to a temp .sh file,
+formatted via `pre-commit run shfmt --files <temp>` (falling back to
+`prek`), then re-indented and written back in place.
+
+When invoked without arguments, every .yml/.yaml under .github/ plus every
+.md file in the repo is scanned. When invoked with file arguments (the
+pre-commit case), only those files are processed.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Union
+
+REPO = Path(__file__).resolve().parents[2]
+
+_HOOK_RUNNER = next((cmd for cmd in ("pre-commit", "prek") if shutil.which(cmd)), None)
+if _HOOK_RUNNER is None:
+    sys.exit("error: neither `pre-commit` nor `prek` found on PATH")
+
+RUN_BLOCK_RE = re.compile(r"^(?P<prefix>[ \t]*(?:- )?)run:[ \t]*\|[+-]?[ \t]*$")
+RUN_INLINE_RE = re.compile(
+    r"^(?P<prefix>[ \t]*(?:- )?)run:[ \t]+" r"(?P<value>(?!\|[+-]?[ \t]*$)\S.*?)[ \t]*$"
+)
+MD_BASH_OPEN_RE = re.compile(r"^(?P<indent>[ ]{0,3})`{3}bash[ \t]*$")
+MD_FENCE_CLOSE_RE = re.compile(r"^[ ]{0,3}`{3,}[ \t]*$")
+
+
+@dataclass(frozen=True)
+class BlockRun:
+    """A `run: |` block scalar; `body_start:body_end` slices into `lines`."""
+
+    body_start: int
+    body_end: int
+    body_indent: int
+
+
+@dataclass(frozen=True)
+class InlineRun:
+    """A single-line `run: value` at `line_idx`."""
+
+    line_idx: int
+    prefix: str
+    value: str
+
+
+@dataclass(frozen=True)
+class MdBashBlock:
+    """A markdown ``` ```bash ``` fenced code block.
+
+    `body_start:body_end` slices into the file's lines; `open_line_idx`
+    points at the opening fence line.
+    """
+
+    open_line_idx: int
+    body_start: int
+    body_end: int
+    body_indent: int
+
+
+RunItem = Union[BlockRun, InlineRun]
+
+
+def _scan_block_body(
+    lines: list[str], body_start: int, run_col: int
+) -> tuple[int | None, int]:
+    """Locate the body of a `run: |` block scalar starting at `body_start`.
+
+    Returns `(body_indent, scan_end)`. `scan_end` is the line index where the
+    outer scanner should resume. `body_indent` is `None` when no body is
+    present (the scalar is empty, or the next non-blank line has indent
+    `<= run_col`).
+    """
+    body_indent: int | None = None
+    scan_end = len(lines)
+    for idx in range(body_start, len(lines)):
+        line = lines[idx]
+        if line.strip() == "":
+            continue
+        indent = len(line) - len(line.lstrip(" "))
+        if body_indent is None:
+            if indent > run_col:
+                body_indent = indent
+            else:
+                scan_end = idx
+                break
+        elif indent < body_indent:
+            scan_end = idx
+            break
+    if body_indent is not None:
+        while scan_end > body_start and lines[scan_end - 1].strip() == "":
+            scan_end -= 1
+        if scan_end <= body_start:
+            body_indent = None
+    return body_indent, scan_end
+
+
+def find_run_blocks(lines: list[str]) -> list[RunItem]:
+    """Return run items in document order."""
+    items: list[RunItem] = []
+    line_idx = 0
+    while line_idx < len(lines):
+        line = lines[line_idx]
+        if block_match := RUN_BLOCK_RE.match(line):
+            run_col = len(block_match.group("prefix"))
+            body_start = line_idx + 1
+            body_indent, scan_end = _scan_block_body(lines, body_start, run_col)
+            if body_indent is not None:
+                items.append(
+                    BlockRun(
+                        body_start=body_start,
+                        body_end=scan_end,
+                        body_indent=body_indent,
+                    )
+                )
+            line_idx = scan_end
+            continue
+        if inline_match := RUN_INLINE_RE.match(line):
+            items.append(
+                InlineRun(
+                    line_idx=line_idx,
+                    prefix=inline_match.group("prefix"),
+                    value=inline_match.group("value"),
+                )
+            )
+        line_idx += 1
+    return items
+
+
+def find_md_bash_blocks(lines: list[str]) -> list[MdBashBlock]:
+    """Return ``` ```bash ``` fenced code blocks in document order."""
+    blocks: list[MdBashBlock] = []
+    line_idx = 0
+    while line_idx < len(lines):
+        open_match = MD_BASH_OPEN_RE.match(lines[line_idx])
+        if not open_match:
+            line_idx += 1
+            continue
+        body_start = line_idx + 1
+        close_idx = next(
+            (
+                j
+                for j in range(body_start, len(lines))
+                if MD_FENCE_CLOSE_RE.match(lines[j])
+            ),
+            None,
+        )
+        if close_idx is None:
+            line_idx = body_start
+            continue
+        body = lines[body_start:close_idx]
+        non_blank = [b for b in body if b.strip()]
+        body_indent = (
+            min(len(b) - len(b.lstrip(" ")) for b in non_blank)
+            if non_blank
+            else len(open_match.group("indent"))
+        )
+        blocks.append(
+            MdBashBlock(
+                open_line_idx=line_idx,
+                body_start=body_start,
+                body_end=close_idx,
+                body_indent=body_indent,
+            )
+        )
+        line_idx = close_idx + 1
+    return blocks
+
+
+def dedent(lines: list[str], n: int) -> list[str]:
+    pad = " " * n
+    return [
+        (
+            ""
+            if line.strip() == ""
+            else (line[n:] if line.startswith(pad) else line.lstrip(" "))
+        )
+        for line in lines
+    ]
+
+
+def reindent(lines: list[str], n: int) -> list[str]:
+    pad = " " * n
+    return [pad + line if line else "" for line in lines]
+
+
+_SHFMT_ERR_RE = re.compile(r"\.sh:\d+:\d+:\s")
+_GHA_EXPR_RE = re.compile(r"\$\{\{.*?\}\}", re.DOTALL)
+_GHA_PLACEHOLDER_RE = re.compile(r"__GHA_EXPR_(\d+)__")
+
+
+def _encode_gha_exprs(text: str) -> tuple[str, list[str]]:
+    """Replace `${{ ... }}` expressions with bash-safe placeholder identifiers."""
+    exprs: list[str] = []
+
+    def repl(match: re.Match[str]) -> str:
+        exprs.append(match.group(0))
+        return f"__GHA_EXPR_{len(exprs) - 1}__"
+
+    return _GHA_EXPR_RE.sub(repl, text), exprs
+
+
+def _decode_gha_exprs(text: str, exprs: list[str]) -> str:
+    """Restore `${{ ... }}` expressions from placeholder identifiers."""
+    return _GHA_PLACEHOLDER_RE.sub(lambda m: exprs[int(m.group(1))], text)
+
+
+def shfmt_via_hook(tmp_path: Path) -> tuple[bool, str]:
+    # `${{ ... }}` is not valid shell, so swap it for a placeholder identifier
+    # that shfmt can parse, then restore it after formatting.
+    encoded, exprs = _encode_gha_exprs(tmp_path.read_text())
+    if exprs:
+        tmp_path.write_text(encoded)
+    res = subprocess.run(
+        [_HOOK_RUNNER, "run", "shfmt", "--files", str(tmp_path)],
+        cwd=REPO,
+        capture_output=True,
+        text=True,
+    )
+    output = res.stdout + res.stderr
+    # shfmt emits parse errors as "<path>:<line>:<col>: <message>".
+    parse_err = bool(_SHFMT_ERR_RE.search(output))
+    # A non-zero exit that is neither a parse error nor pre-commit's "I had
+    # to modify files" signal means the hook itself failed to run (missing
+    # binary, install failure, bad config, ...). Surface that loudly rather
+    # than silently treating it as a no-op.
+    if (
+        res.returncode != 0
+        and not parse_err
+        and "files were modified by this hook" not in output
+    ):
+        sys.exit(
+            f"error: `{_HOOK_RUNNER} run shfmt` failed with exit {res.returncode}:\n{output}"
+        )
+    if exprs and not parse_err:
+        tmp_path.write_text(_decode_gha_exprs(tmp_path.read_text(), exprs))
+    return not parse_err, output
+
+
+def _skip(path: Path, where: int, kind: str, output: str) -> None:
+    print(
+        f"  shfmt could not parse {kind} at {path}:{where + 1} — skipped",
+        file=sys.stderr,
+    )
+    print(f"    {output.strip()}", file=sys.stderr)
+
+
+def process_yaml_file(path: Path, tmp_path: Path) -> int:
+    text = path.read_text()
+    had_nl = text.endswith("\n")
+    lines = text.split("\n")
+    if had_nl:
+        lines = lines[:-1]
+    items = find_run_blocks(lines)
+    if not items:
+        return 0
+    changed = 0
+    # Process in reverse so earlier indices remain valid as we splice.
+    for item in reversed(items):
+        if isinstance(item, BlockRun):
+            body = lines[item.body_start : item.body_end]
+            tmp_path.write_text("\n".join(dedent(body, item.body_indent)) + "\n")
+            ok, output = shfmt_via_hook(tmp_path)
+            if not ok:
+                _skip(path, item.body_start, "block", output)
+                continue
+            formatted = tmp_path.read_text().rstrip("\n")
+            new_body = reindent(formatted.split("\n"), item.body_indent)
+            if new_body != body:
+                lines[item.body_start : item.body_end] = new_body
+                changed += 1
+        else:
+            tmp_path.write_text(item.value + "\n")
+            ok, output = shfmt_via_hook(tmp_path)
+            if not ok:
+                _skip(path, item.line_idx, "inline run", output)
+                continue
+            formatted = tmp_path.read_text().rstrip("\n")
+            if formatted == item.value:
+                continue
+            formatted_lines = formatted.split("\n")
+            if len(formatted_lines) == 1:
+                lines[item.line_idx] = f"{item.prefix}run: {formatted}"
+            else:
+                body_indent = len(item.prefix) + 2
+                lines[item.line_idx : item.line_idx + 1] = [
+                    f"{item.prefix}run: |",
+                    *reindent(formatted_lines, body_indent),
+                ]
+            changed += 1
+    new_text = "\n".join(lines) + ("\n" if had_nl else "")
+    if new_text != text:
+        path.write_text(new_text)
+    return changed
+
+
+def process_md_file(path: Path, tmp_path: Path) -> int:
+    text = path.read_text()
+    had_nl = text.endswith("\n")
+    lines = text.split("\n")
+    if had_nl:
+        lines = lines[:-1]
+    blocks = find_md_bash_blocks(lines)
+    if not blocks:
+        return 0
+    changed = 0
+    for block in reversed(blocks):
+        body = lines[block.body_start : block.body_end]
+        tmp_path.write_text("\n".join(dedent(body, block.body_indent)) + "\n")
+        ok, output = shfmt_via_hook(tmp_path)
+        if not ok:
+            _skip(path, block.open_line_idx, "```bash block", output)
+            continue
+        formatted = tmp_path.read_text().rstrip("\n")
+        formatted_lines = formatted.split("\n") if formatted else []
+        new_body = reindent(formatted_lines, block.body_indent)
+        if new_body != body:
+            lines[block.body_start : block.body_end] = new_body
+            changed += 1
+    new_text = "\n".join(lines) + ("\n" if had_nl else "")
+    if new_text != text:
+        path.write_text(new_text)
+    return changed
+
+
+def process_file(path: Path, tmp_path: Path) -> int:
+    if path.suffix in (".yml", ".yaml"):
+        return process_yaml_file(path, tmp_path)
+    if path.suffix == ".md":
+        return process_md_file(path, tmp_path)
+    return 0
+
+
+def gather_files(argv: list[str]) -> list[Path]:
+    """Return YAML workflow/action files and markdown files that we should
+    process — either the paths in `argv` or, when `argv` is empty, every
+    such file in the repo (skipping `external/`)."""
+    if argv:
+        candidates: list[Path] = [
+            (REPO / a).resolve() if not Path(a).is_absolute() else Path(a) for a in argv
+        ]
+    else:
+        gh = REPO / ".github"
+        candidates = [
+            *gh.rglob("*.yml"),
+            *gh.rglob("*.yaml"),
+            *(
+                p
+                for p in REPO.rglob("*.md")
+                if "external" not in p.relative_to(REPO).parts
+            ),
+        ]
+    return sorted(
+        p
+        for p in candidates
+        if p.exists()
+        and (
+            (p.suffix in (".yml", ".yaml") and ".github" in p.parts)
+            or p.suffix == ".md"
+        )
+    )
+
+
+def main(argv: list[str]) -> int:
+    files = gather_files(argv)
+    if not files:
+        return 0
+    with tempfile.TemporaryDirectory(prefix="format-inline-bash-") as tmpdir:
+        tmp_path = Path(tmpdir) / "shfmt.sh"
+        total = 0
+        for f in files:
+            n = process_file(f, tmp_path)
+            if n:
+                print(f"{f.relative_to(REPO)}: reformatted {n} block(s)")
+                total += n
+        return 1 if total else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

.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 xrpl/consensus          |
+
+## xrpld Modules (Application Implementation)
+
+| Level / Tier | Module(s)                   |
+| ------------ | --------------------------- |
+| 05           | xrpld/conditions            |
+| 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,18 @@
+Loop: xrpld.app xrpld.overlay
+  xrpld.app > xrpld.overlay
+
+Loop: xrpld.app xrpld.rpc
+  xrpld.rpc > xrpld.app
+
+Loop: xrpld.app xrpld.shamap
+  xrpld.shamap > xrpld.app
+
+Loop: xrpld.app xrpld.telemetry
+  xrpld.telemetry ~= xrpld.app
+
+Loop: xrpld.overlay xrpld.rpc
+  xrpld.rpc ~= xrpld.overlay
+
+Loop: xrpld.overlay xrpld.telemetry
+  xrpld.telemetry ~= xrpld.overlay
+

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

@@ -0,0 +1,344 @@
+benchmarks.libxrpl > xrpl.basics
+benchmarks.libxrpl > xrpl.config
+benchmarks.libxrpl > xrpl.nodestore
+libxrpl.basics > xrpl.basics
+libxrpl.conditions > xrpl.basics
+libxrpl.conditions > xrpl.conditions
+libxrpl.config > xrpl.basics
+libxrpl.config > xrpl.config
+libxrpl.consensus > xrpl.basics
+libxrpl.consensus > xrpl.consensus
+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.shamap
+libxrpl.net > xrpl.basics
+libxrpl.net > xrpl.net
+libxrpl.nodestore > xrpl.basics
+libxrpl.nodestore > xrpl.config
+libxrpl.nodestore > xrpl.json
+libxrpl.nodestore > xrpl.nodestore
+libxrpl.nodestore > xrpl.protocol
+libxrpl.peerfinder > xrpl.basics
+libxrpl.peerfinder > xrpl.peerfinder
+libxrpl.peerfinder > xrpl.protocol
+libxrpl.protocol > xrpl.basics
+libxrpl.protocol > xrpl.json
+libxrpl.protocol > xrpl.protocol
+libxrpl.rdb > xrpl.basics
+libxrpl.rdb > xrpl.config
+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.config
+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.telemetry > xrpl.basics
+libxrpl.telemetry > xrpl.config
+libxrpl.telemetry > xrpl.protocol
+libxrpl.telemetry > xrpl.telemetry
+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.telemetry
+libxrpl.tx > xrpl.tx
+test.app > test.jtx
+test.app > test.unit_test
+test.app > xrpl.basics
+test.app > xrpl.config
+test.app > xrpl.consensus
+test.app > xrpl.core
+test.app > xrpld.app
+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 > xrpl.basics
+test.basics > xrpl.core
+test.basics > xrpl.json
+test.basics > xrpl.protocol
+test.beast > xrpl.basics
+test.conditions > xrpl.basics
+test.conditions > xrpl.conditions
+test.consensus > test.jtx
+test.consensus > xrpl.basics
+test.consensus > xrpld.app
+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.config
+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.json > test.jtx
+test.json > xrpl.json
+test.jtx > test.unit_test
+test.jtx > xrpl.basics
+test.jtx > xrpl.config
+test.jtx > xrpl.core
+test.jtx > xrpld.app
+test.jtx > xrpld.core
+test.jtx > xrpld.overlay
+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 > xrpl.config
+test.nodestore > xrpld.app
+test.nodestore > xrpld.core
+test.nodestore > xrpld.telemetry
+test.nodestore > xrpl.nodestore
+test.nodestore > xrpl.rdb
+test.overlay > test.jtx
+test.overlay > test.unit_test
+test.overlay > xrpl.basics
+test.overlay > xrpl.config
+test.overlay > xrpld.app
+test.overlay > xrpld.core
+test.overlay > xrpld.overlay
+test.overlay > xrpl.json
+test.overlay > xrpl.nodestore
+test.overlay > xrpl.peerfinder
+test.overlay > xrpl.protocol
+test.overlay > xrpl.resource
+test.overlay > xrpl.server
+test.overlay > xrpl.shamap
+test.protocol > test.jtx
+test.protocol > test.unit_test
+test.protocol > xrpl.basics
+test.protocol > xrpld.core
+test.protocol > xrpl.json
+test.protocol > xrpl.protocol
+test.rpc > test.jtx
+test.rpc > xrpl.basics
+test.rpc > xrpl.config
+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 > xrpl.config
+test.server > xrpld.app
+test.server > xrpld.core
+test.server > xrpl.json
+test.server > xrpl.protocol
+test.server > xrpl.server
+test.unit_test > xrpl.basics
+test.unit_test > xrpl.protocol
+tests.libxrpl > xrpl.basics
+tests.libxrpl > xrpl.config
+tests.libxrpl > xrpl.consensus
+tests.libxrpl > xrpl.core
+tests.libxrpl > xrpld.app
+tests.libxrpl > xrpld.rpc
+tests.libxrpl > xrpl.json
+tests.libxrpl > xrpl.ledger
+tests.libxrpl > xrpl.net
+tests.libxrpl > xrpl.nodestore
+tests.libxrpl > xrpl.peerfinder
+tests.libxrpl > xrpl.protocol
+tests.libxrpl > xrpl.protocol_autogen
+tests.libxrpl > xrpl.rdb
+tests.libxrpl > xrpl.resource
+tests.libxrpl > xrpl.server
+tests.libxrpl > xrpl.shamap
+tests.libxrpl > xrpl.telemetry
+tests.libxrpl > xrpl.tx
+xrpl.conditions > xrpl.basics
+xrpl.conditions > xrpl.protocol
+xrpl.config > xrpl.basics
+xrpl.consensus > xrpl.basics
+xrpl.consensus > xrpl.json
+xrpl.consensus > xrpl.ledger
+xrpl.consensus > xrpl.protocol
+xrpl.consensus > xrpl.telemetry
+xrpl.core > xrpl.basics
+xrpl.core > xrpl.json
+xrpl.core > xrpl.protocol
+xrpl.json > xrpl.basics
+xrpl.ledger > xrpl.basics
+xrpl.ledger > xrpl.json
+xrpl.ledger > xrpl.nodestore
+xrpl.ledger > xrpl.protocol
+xrpl.ledger > xrpl.shamap
+xrpl.net > xrpl.basics
+xrpl.nodestore > xrpl.basics
+xrpl.nodestore > xrpl.config
+xrpl.nodestore > xrpl.json
+xrpl.nodestore > xrpl.protocol
+xrpl.peerfinder > xrpl.basics
+xrpl.peerfinder > 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.shamap > xrpl.basics
+xrpl.shamap > xrpl.nodestore
+xrpl.shamap > xrpl.protocol
+xrpl.telemetry > xrpl.basics
+xrpl.telemetry > xrpl.config
+xrpl.telemetry > xrpl.core
+xrpl.telemetry > xrpl.protocol
+xrpl.tx > xrpl.basics
+xrpl.tx > xrpl.core
+xrpl.tx > xrpl.ledger
+xrpl.tx > xrpl.protocol
+xrpl.tx > xrpl.telemetry
+xrpld.app > test.unit_test
+xrpld.app > xrpl.basics
+xrpld.app > xrpl.config
+xrpld.app > xrpl.consensus
+xrpld.app > xrpl.core
+xrpld.app > xrpld.core
+xrpld.app > xrpl.json
+xrpld.app > xrpl.ledger
+xrpld.app > xrpl.net
+xrpld.app > xrpl.nodestore
+xrpld.app > xrpl.peerfinder
+xrpld.app > xrpl.protocol
+xrpld.app > xrpl.rdb
+xrpld.app > xrpl.resource
+xrpld.app > xrpl.server
+xrpld.app > xrpl.shamap
+xrpld.app > xrpl.telemetry
+xrpld.app > xrpl.tx
+xrpld.core > xrpl.basics
+xrpld.core > xrpl.config
+xrpld.core > xrpl.core
+xrpld.core > xrpl.net
+xrpld.core > xrpl.protocol
+xrpld.core > xrpl.rdb
+xrpld.overlay > xrpl.basics
+xrpld.overlay > xrpl.config
+xrpld.overlay > xrpl.consensus
+xrpld.overlay > xrpl.core
+xrpld.overlay > xrpld.core
+xrpld.overlay > xrpld.peerfinder
+xrpld.overlay > xrpl.json
+xrpld.overlay > xrpl.ledger
+xrpld.overlay > xrpl.peerfinder
+xrpld.overlay > xrpl.protocol
+xrpld.overlay > xrpl.resource
+xrpld.overlay > xrpl.server
+xrpld.overlay > xrpl.shamap
+xrpld.overlay > xrpl.telemetry
+xrpld.overlay > xrpl.tx
+xrpld.peerfinder > xrpl.basics
+xrpld.peerfinder > xrpld.app
+xrpld.peerfinder > xrpld.core
+xrpld.peerfinder > xrpl.peerfinder
+xrpld.peerfinder > xrpl.rdb
+xrpld.perflog > xrpl.basics
+xrpld.perflog > xrpl.config
+xrpld.perflog > xrpl.core
+xrpld.perflog > xrpld.app
+xrpld.perflog > xrpl.json
+xrpld.perflog > xrpl.nodestore
+xrpld.perflog > xrpl.protocol
+xrpld.perflog > xrpl.server
+xrpld.perflog > xrpl.telemetry
+xrpld.rpc > xrpl.basics
+xrpld.rpc > xrpl.config
+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.telemetry
+xrpld.rpc > xrpl.tx
+xrpld.shamap > xrpl.basics
+xrpld.shamap > xrpld.core
+xrpld.shamap > xrpl.nodestore
+xrpld.shamap > xrpl.protocol
+xrpld.shamap > xrpl.shamap
+xrpld.telemetry > xrpl.basics
+xrpld.telemetry > xrpl.consensus
+xrpld.telemetry > xrpl.core
+xrpld.telemetry > xrpld.core
+xrpld.telemetry > xrpl.json
+xrpld.telemetry > xrpl.nodestore
+xrpld.telemetry > xrpl.protocol
+xrpld.telemetry > xrpl.rdb
+xrpld.telemetry > xrpl.server
+xrpld.telemetry > xrpl.telemetry

.github/scripts/otel-naming/README.md

@@ -0,0 +1,71 @@
+# OTel naming-consistency check
+
+`check_otel_naming.py` enforces the OpenTelemetry span-attribute naming
+convention documented in
+[CONTRIBUTING.md](../../../CONTRIBUTING.md#telemetry-span-attribute-naming)
+across every layer of the telemetry pipeline. The `*SpanNames.h` constants are
+the single source of truth (L1); every other layer must agree with them.
+
+## Running locally
+
+```
+python .github/scripts/otel-naming/check_otel_naming.py
+```
+
+It takes no arguments, can be run from any directory inside the repo, and uses
+only the Python standard library (no `pip install`, matching the levelization
+check). A non-zero exit code means a violation was found; the output lists each
+violation as `RULE | location | token | expected`.
+
+## What it checks
+
+The valid key set is **derived dynamically from the OTel code** — there is no
+hardcoded allowlist:
+
+- **L1 keys** come from the `namespace attr { ... }` blocks of every
+  `*SpanNames.h`, resolving the `makeStr("x")` / `join(seg::a, seg::b)` DSL
+  (cross-file, so `join(seg::rpc, ...)` resolves `seg::rpc` from the base
+  `SpanNames.h`). Each constant is resolved against **its own** header, so two
+  headers that define a same-named constant (e.g. a base `attr::ledgerHash` and
+  a domain `attr::ledgerHash`) each contribute their real wire key — a later
+  header cannot clobber an earlier one's value in a flat table.
+- **Legitimate dotted keys** = ONLY the keys the code actually sets as resource
+  attributes, i.e. the entries inside `Telemetry.cpp`'s `Resource::Create({...})`
+  call: the `semconv::service::*` keys (`service.*`) plus any `attr::<name>`
+  constants passed there (`xrpl.network.*`). A dotted key that is _declared_ in a
+  header but never set as a resource attr is a span attribute in resource
+  clothing — a Rule-A violation, even if it lives in the base `SpanNames.h`.
+
+### Rules (each fails the build, when its inputs are present)
+
+| Rule | Check                                                                                                                                                                                                                                                                                    |
+| ---- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| A    | No stray dotted span-attribute key (only the derived resource keys may be dotted).                                                                                                                                                                                                       |
+| G    | Attribute keys are `lower_snake_case` (`^[a-z][a-z0-9_]*$` per dot-segment) — no camelCase, UPPERCASE, or spaces.                                                                                                                                                                        |
+| F    | No string literals as attribute keys or span-name arguments in `setAttribute`/`addEvent`/`span`/`rootSpan`/`childSpan` (`rootSpan` shares `span`'s `(cat, prefix, name)` signature). Attribute _values_ are exempt (runtime data); `*SpanNames.h` definitions and test files are exempt. |
+| B    | Every collector `spanmetrics.dimensions` name exists in the L1 key set.                                                                                                                                                                                                                  |
+| C    | Every Tempo span-filter tag exists in the L1 key set.                                                                                                                                                                                                                                    |
+| D    | Every dashboard label resolves to an L1 span attribute, a native-metric label (L6, emitted by MetricsRegistry), or a Prometheus/Grafana builtin. TraceQL scope prefixes (`span.`/`resource.`/…) are stripped before the L1 lookup.                                                       |
+| E    | No dotted `xrpl.<domain>.<field>` attribute key in the runbook (only the L1 resource attrs `xrpl.network.*` may be dotted). Span names, filenames, OTel-standard keys, and metric labels are not flagged.                                                                                |
+
+Rule F runs **unconditionally** (it is a purely syntactic check on the
+call-sites and needs no `*SpanNames.h`), so a code path that calls
+`SpanGuard::span`/`setAttribute` directly without ever defining a header is
+still caught.
+
+### Warnings (printed, never fail the build)
+
+| Rule | Check                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ---- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| H    | A namespace-qualified constant (e.g. `foo::bar::myKey`) used at a telemetry call-site is not defined in any `*SpanNames.h`. The constant should live in the proper header; defining it in-place bypasses rules A/G/F. Warns rather than fails — the argument may be a legitimately dynamic value, and the header may live on a later branch. Bare locals and `std::` names are not warned.                                                                                                                                                                                                                                                                                                                   |
+| M    | A constant defined in a `*SpanNames.h` that no code in `src/**` or `include/**` references — the reverse of every failing rule above, which all start from a consumer and look for its L1 source. Deleting the last `setAttribute(attr::foo, …)` while leaving `attr::foo` in the header otherwise passes every rule and the compiler, and the telemetry silently stops being emitted. Whole files are searched rather than telemetry call sites only, since a constant is also passed to helpers and used as an attribute _value_. Constants only test code references are reported separately. Warns rather than fails: in a stacked chain a constant may legitimately land a commit before its call site. |
+
+## Presence-gated
+
+Every rule runs **only when the source files it needs are present** in the tree
+and is otherwise skipped (printed as `SKIP: <rule> — <reason>`), never failed.
+This keeps the check correct no matter how telemetry work is split across PRs —
+a stacked chain, one large PR, or independent per-stage PRs where (for example)
+the collector config lands before the dashboards. The collector/Tempo/dashboard/
+runbook layers are introduced in later phases; on a branch without them, only
+the L1-intrinsic rules (A, G, F) run.

.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/install.md
+
+popd
+echo "Processing complete."

.github/scripts/rename/cmake.sh

@@ -0,0 +1,88 @@
+#!/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 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/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/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "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/install.md
+${SED_COMMAND} -i 's@github.com/XRPLF/xrpld@github.com/XRPLF/rippled@g' docs/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/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "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,56 @@
+#!/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
+
+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,402 @@
+#!/usr/bin/env python3
+import argparse
+import dataclasses
+import itertools
+import json
+from pathlib import Path
+
+THIS_DIR = Path(__file__).parent.resolve()
+
+_BASE_CMAKE_ARGS = [
+    "-Dtests=ON",
+    "-Dwerr=ON",
+    "-Dxrpld=ON",
+    "-Dwextra=ON",
+    "-Drust=ON",
+]
+
+# The package formats a config can be packaged as, each with its own
+# install-test job in reusable-package.yml.
+PACKAGE_TYPES = ("deb", "rpm")
+
+# The package name a variant suffixes, as build_pkg.py's BASE_NAME spells it:
+# the two have to agree, or the artifact globs miss what was built.
+BASE_NAME = "xrpld"
+
+# Maps sanitizer names (as used in cmake) to short config-name suffixes.
+_SANITIZER_SUFFIX: dict[str, str] = {
+    "address": "asan",
+    "undefinedbehavior": "ubsan",
+    "thread": "tsan",
+}
+
+
+def config_name(
+    distro: str,
+    compiler: str,
+    build_type: str,
+    arch: str,
+    suffix: str = "",
+    sanitizer: str = "",
+) -> str:
+    """Name a config. Its artifacts are named after it, so packaging reuses this."""
+    parts = [s for s in [suffix, _SANITIZER_SUFFIX.get(sanitizer, "")] if s]
+    return "-".join([f"{distro}-{compiler}-{build_type.lower()}-{arch}", *parts])
+
+
+def get_cmake_args(build_type: str, extra_args: str) -> str:
+    """Get the full list of CMake arguments for a config."""
+    args = _BASE_CMAKE_ARGS.copy()
+    if extra_args:
+        args.extend(extra_args.split())
+    return " ".join(args)
+
+
+# ---------------------------------------------------------------------------
+# Input types — shapes of the JSON config files
+# ---------------------------------------------------------------------------
+
+
+# Every config must declare 'minimal'. Minimal configs form the reduced matrix
+# built for pull requests by default; the full matrix adds the rest.
+#
+# Configs may also opt into 'benchmark' to smoke-run the benchmarks, or carry a
+# 'package' map to be packaged as well. Note that either applies to every entry
+# a config expands into, so only set them on configs that expand to a single
+# combination.
+
+
+@dataclasses.dataclass
+class PackageConfig:
+    """The 'package' map of a config whose binaries are also packaged."""
+
+    type: str  # has to match what the image provides
+    # The packaging container image: a vanilla distro image, not the nix image
+    # the config itself builds in.
+    image: str
+    # A flavour of the package, named xrpld-<variant>, for a config whose
+    # binaries are not the plain release build. A variant needs no counterpart
+    # in the other format.
+    variant: str = ""
+
+    def __post_init__(self) -> None:
+        assert self.type in PACKAGE_TYPES, (
+            f"unsupported package type {self.type!r}: "
+            f"use one of {', '.join(PACKAGE_TYPES)}."
+        )
+
+
+@dataclasses.dataclass
+class LinuxConfig:
+    """One entry in a linux.json 'configs' array."""
+
+    compiler: list[str]
+    build_type: list[str]
+    arch: list[str]
+    minimal: bool
+    benchmark: bool = False  # if true, smoke-run the benchmarks after testing
+    sanitizers: list[str] = dataclasses.field(default_factory=list)
+    suffix: str = ""
+    extra_cmake_args: str = ""
+    package: PackageConfig | None = None  # set to also package this config
+
+    def __post_init__(self) -> None:
+        if isinstance(self.package, dict):
+            self.package = PackageConfig(**self.package)
+
+
+@dataclasses.dataclass
+class LinuxFile:
+    """Shape of linux.json."""
+
+    image_tag: str
+    configs: dict[str, list[LinuxConfig]]  # distro → configs
+
+    @classmethod
+    def load(cls, path: Path) -> "LinuxFile":
+        data = json.loads(path.read_text())
+        return cls(
+            image_tag=data["image_tag"],
+            configs={
+                distro: [LinuxConfig(**c) for c in cfgs]
+                for distro, cfgs in data["configs"].items()
+            },
+        )
+
+
+@dataclasses.dataclass
+class PlatformConfig:
+    """One entry in macos.json's or windows.json's 'configs' array."""
+
+    build_type: list[str]
+    minimal: bool
+    build_only: bool = False  # if true, skip tests (e.g. macos/Windows Debug)
+    benchmark: bool = False  # if true, smoke-run the benchmarks after testing
+    extra_cmake_args: str = ""
+    # "" is the runner's system compiler, "nix" the flake's CI environment.
+    # macOS only: Linux always builds in a Nix image, Windows has no Nix.
+    toolchain: str = ""
+
+    def __post_init__(self) -> None:
+        if isinstance(self.build_type, str):
+            self.build_type = [self.build_type]
+
+
+@dataclasses.dataclass
+class PlatformFile:
+    """Shape of macos.json and windows.json."""
+
+    platform: str  # e.g. "macos/arm64" or "windows/amd64"
+    runner: list[str]  # GitHub Actions runner labels
+    configs: list[PlatformConfig]
+
+    @classmethod
+    def load(cls, path: Path) -> "PlatformFile":
+        data = json.loads(path.read_text())
+        return cls(
+            platform=data["platform"],
+            runner=data["runner"],
+            configs=[PlatformConfig(**c) for c in data["configs"]],
+        )
+
+
+# ---------------------------------------------------------------------------
+# Output types — shapes of the generated GitHub Actions matrix entries
+# ---------------------------------------------------------------------------
+
+
+@dataclasses.dataclass
+class Architecture:
+    platform: str
+    runner: list[str]
+
+
+@dataclasses.dataclass
+class MatrixEntry:
+    """One entry in the generated build/test strategy matrix."""
+
+    config_name: str
+    cmake_args: str
+    cmake_target: str
+    build_only: bool
+    benchmark: bool
+    build_type: str
+    architecture: Architecture
+    sanitizers: str
+    image: str = ""  # container image; empty for macOS/Windows (runs natively)
+    compiler: str = ""  # compiler name ("gcc" or "clang"); empty for macOS/Windows
+    toolchain: str = ""  # "nix" for the flake's CI environment; see PlatformConfig
+
+
+@dataclasses.dataclass
+class PackagingEntry:
+    """One entry in the generated packaging strategy matrix."""
+
+    xrpld_artifact_name: str
+    validator_keys_artifact_name: str
+    image: str
+    package_type: str  # "deb" or "rpm"; drives the format-specific steps
+    package_variant: str  # passed to build_pkg.py --variant; empty for xrpld
+    package_name: str  # the name it builds under, which the artifact globs use
+
+
+# ---------------------------------------------------------------------------
+# Matrix expansion
+# ---------------------------------------------------------------------------
+
+_ARCHS: dict[str, Architecture] = {
+    "amd64": Architecture(
+        platform="linux/amd64", runner=["self-hosted", "Linux", "X64", "heavy"]
+    ),
+    "arm64": Architecture(
+        platform="linux/arm64",
+        runner=["self-hosted", "Linux", "ARM64", "heavy-arm64"],
+    ),
+}
+
+
+def expand_linux_matrix(linux: LinuxFile, minimal: bool) -> list[MatrixEntry]:
+    """Expand a LinuxFile into a flat list of matrix entries.
+
+    Each config entry is expanded over the cross-product of its
+    compiler, build_type, sanitizers, and architecture lists. When 'minimal' is
+    true, only configs flagged as minimal are included.
+    """
+    entries: list[MatrixEntry] = []
+
+    for distro, configs in linux.configs.items():
+        for cfg in configs:
+            if minimal and not cfg.minimal:
+                continue
+            # An empty sanitizers list means "one entry with no sanitizer".
+            effective_sanitizers = cfg.sanitizers or [""]
+            effective_archs = {arch: _ARCHS[arch] for arch in cfg.arch}
+
+            for compiler, build_type, sanitizer, (arch, arch_info) in itertools.product(
+                cfg.compiler,
+                cfg.build_type,
+                effective_sanitizers,
+                effective_archs.items(),
+            ):
+                name = config_name(
+                    distro, compiler, build_type, arch, cfg.suffix, sanitizer
+                )
+                entries.append(
+                    MatrixEntry(
+                        config_name=name,
+                        image=f"ghcr.io/xrplf/xrpld/nix-{distro}:{linux.image_tag}",
+                        cmake_args=get_cmake_args(build_type, cfg.extra_cmake_args),
+                        cmake_target="all",
+                        build_only=False,
+                        benchmark=cfg.benchmark,
+                        build_type=build_type,
+                        architecture=arch_info,
+                        sanitizers=sanitizer,
+                        compiler=compiler,
+                    )
+                )
+
+    return entries
+
+
+def expand_linux_packaging(linux: LinuxFile) -> list[PackagingEntry]:
+    """Generate the packaging matrix from the configs that carry a 'package' map.
+
+    Packaging consumes the binaries that config's build job uploaded, so the
+    artifact names come from the same config name, and a packaged config is one
+    that passes -Dvalidator_keys=ON.
+
+    Packaging itself runs in vanilla distro images (debian:trixie, almalinux:10)
+    instead of the nix-based build images, because deb/rpm tooling (debhelper,
+    rpm-build) is taken from the distro's archive rather than from nixpkgs.
+    """
+    entries = []
+    for distro, configs in linux.configs.items():
+        for cfg in configs:
+            if cfg.package is None:
+                continue
+            for compiler, build_type, arch in itertools.product(
+                cfg.compiler, cfg.build_type, cfg.arch
+            ):
+                # The packaging workflow hardcodes an amd64 runner.
+                assert arch == "amd64", f"cannot package {distro} on {arch}"
+                name = config_name(distro, compiler, build_type, arch, cfg.suffix)
+                entries.append(
+                    PackagingEntry(
+                        xrpld_artifact_name=f"xrpld-{name}",
+                        validator_keys_artifact_name=f"validator-keys-{name}",
+                        image=cfg.package.image,
+                        package_type=cfg.package.type,
+                        package_variant=cfg.package.variant,
+                        package_name=(
+                            f"{BASE_NAME}-{cfg.package.variant}"
+                            if cfg.package.variant
+                            else BASE_NAME
+                        ),
+                    )
+                )
+
+    return entries
+
+
+def package_names_by_type(entries: list[PackagingEntry]) -> dict[str, list[str]]:
+    """The names of the packages in 'entries', keyed by format.
+
+    Derived from the packaging matrix rather than listed again, so the packages
+    the install-test jobs look for are the packages that were built.
+    """
+    return {
+        package_type: sorted(
+            {e.package_name for e in entries if e.package_type == package_type}
+        )
+        for package_type in PACKAGE_TYPES
+    }
+
+
+def expand_platform_matrix(pf: PlatformFile, minimal: bool) -> list[MatrixEntry]:
+    """Expand a PlatformFile (macOS or Windows) into matrix entries.
+
+    When 'minimal' is true, only configs flagged as minimal are included.
+    """
+    platform_name, arch = pf.platform.split("/")
+    is_windows = platform_name == "windows"
+
+    entries: list[MatrixEntry] = []
+    for cfg in pf.configs:
+        if minimal and not cfg.minimal:
+            continue
+        for build_type in cfg.build_type:
+            name = f"{platform_name}-{arch}-{build_type.lower()}"
+            if cfg.toolchain:
+                name += f"-{cfg.toolchain}"
+            entries.append(
+                MatrixEntry(
+                    config_name=name,
+                    cmake_args=get_cmake_args(build_type, cfg.extra_cmake_args),
+                    cmake_target="install" if is_windows else "all",
+                    build_only=cfg.build_only,
+                    benchmark=cfg.benchmark,
+                    build_type=build_type,
+                    architecture=Architecture(platform=pf.platform, runner=pf.runner),
+                    sanitizers="",
+                    toolchain=cfg.toolchain,
+                )
+            )
+    return entries
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Generate a CI strategy matrix for all platforms or a specific one."
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        help="Platform to generate for ('linux', 'macos', or 'windows'). Defaults to all platforms.",
+        choices=["linux", "macos", "windows"],
+        default=None,
+    )
+    parser.add_argument(
+        "-p",
+        "--packaging",
+        help="Emit the Linux packaging matrix instead of the build/test matrix.",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-m",
+        "--minimal",
+        help="Emit only the minimal matrix (the configs flagged 'minimal'), "
+        "used for pull requests by default. If omitted, the full matrix is "
+        "emitted.",
+        action="store_true",
+    )
+    args = parser.parse_args()
+
+    matrix: list[MatrixEntry] | list[PackagingEntry] = []
+
+    if args.packaging:
+        matrix = expand_linux_packaging(LinuxFile.load(THIS_DIR / "linux.json"))
+        # One list per format, so each install-test job installs the packages its
+        # own format produced.
+        for package_type, names in package_names_by_type(matrix).items():
+            print(f"{package_type}_package_names={json.dumps(names)}")
+    else:
+        if args.config in ("linux", None):
+            matrix += expand_linux_matrix(
+                LinuxFile.load(THIS_DIR / "linux.json"), args.minimal
+            )
+        if args.config in ("macos", None):
+            matrix += expand_platform_matrix(
+                PlatformFile.load(THIS_DIR / "macos.json"), args.minimal
+            )
+        if args.config in ("windows", None):
+            matrix += expand_platform_matrix(
+                PlatformFile.load(THIS_DIR / "windows.json"), args.minimal
+            )
+
+    print(f"matrix={json.dumps({'include': [dataclasses.asdict(e) for e in matrix]})}")

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

@@ -0,0 +1,109 @@
+{
+  "image_tag": "sha-060957e",
+  "configs": {
+    "ubuntu": [
+      {
+        "compiler": ["gcc"],
+        "build_type": ["Debug"],
+        "arch": ["amd64"],
+        "minimal": true,
+        "suffix": "coverage",
+        "extra_cmake_args": "-DUNIT_TEST_REFERENCE_FEE=500 -Dcoverage=ON -Dcoverage_format=xml -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_C_FLAGS=-O0 -DCMAKE_CXX_FLAGS=-O0"
+      },
+      {
+        "compiler": ["clang"],
+        "build_type": ["Release"],
+        "arch": ["amd64"],
+        "minimal": true,
+        "benchmark": true
+      },
+
+      {
+        "compiler": ["gcc"],
+        "build_type": ["Release"],
+        "arch": ["amd64"],
+        "minimal": false
+      },
+      {
+        "compiler": ["gcc", "clang"],
+        "build_type": ["Debug", "Release"],
+        "arch": ["arm64"],
+        "minimal": false
+      },
+
+      {
+        "compiler": ["gcc", "clang"],
+        "build_type": ["Debug", "Release"],
+        "arch": ["amd64"],
+        "minimal": false,
+        "sanitizers": ["address", "undefinedbehavior"]
+      },
+
+      {
+        "compiler": ["clang"],
+        "build_type": ["Debug"],
+        "arch": ["amd64"],
+        "minimal": false,
+        "suffix": "voidstar",
+        "extra_cmake_args": "-Dvoidstar=ON"
+      },
+      {
+        "compiler": ["clang"],
+        "build_type": ["Release"],
+        "arch": ["amd64"],
+        "minimal": false,
+        "suffix": "reffee",
+        "extra_cmake_args": "-DUNIT_TEST_REFERENCE_FEE=1000"
+      },
+      {
+        "compiler": ["gcc"],
+        "build_type": ["Debug"],
+        "arch": ["amd64"],
+        "minimal": false,
+        "suffix": "unity",
+        "extra_cmake_args": "-Dunity=ON"
+      }
+    ],
+
+    "debian": [
+      {
+        "compiler": ["gcc"],
+        "build_type": ["Release"],
+        "arch": ["amd64"],
+        "minimal": false,
+        "extra_cmake_args": "-Dvalidator_keys=ON",
+        "package": {
+          "type": "deb",
+          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-49cdc10"
+        }
+      },
+      {
+        "compiler": ["gcc"],
+        "build_type": ["Release"],
+        "arch": ["amd64"],
+        "minimal": false,
+        "suffix": "assert",
+        "extra_cmake_args": "-Dvalidator_keys=ON -Dassert=ON",
+        "package": {
+          "type": "deb",
+          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-49cdc10",
+          "variant": "assert"
+        }
+      }
+    ],
+
+    "rhel": [
+      {
+        "compiler": ["gcc"],
+        "build_type": ["Release"],
+        "arch": ["amd64"],
+        "minimal": false,
+        "extra_cmake_args": "-Dvalidator_keys=ON",
+        "package": {
+          "type": "rpm",
+          "image": "ghcr.io/xrplf/xrpld/packaging-rhel:sha-49cdc10"
+        }
+      }
+    ]
+  }
+}

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

@@ -0,0 +1,30 @@
+{
+  "platform": "macos/arm64",
+  "runner": ["self-hosted", "macOS", "ARM64", "macos-26-apple-clang-21"],
+  "configs": [
+    {
+      "build_type": "Release",
+      "extra_cmake_args": "-DCMAKE_POLICY_VERSION_MINIMUM=3.5",
+      "minimal": true
+    },
+    {
+      "build_type": "Debug",
+      "extra_cmake_args": "-DCMAKE_POLICY_VERSION_MINIMUM=3.5",
+      "build_only": true,
+      "minimal": false
+    },
+    {
+      "build_type": "Release",
+      "extra_cmake_args": "-DCMAKE_POLICY_VERSION_MINIMUM=3.5",
+      "toolchain": "nix",
+      "minimal": false
+    },
+    {
+      "build_type": "Debug",
+      "extra_cmake_args": "-DCMAKE_POLICY_VERSION_MINIMUM=3.5",
+      "toolchain": "nix",
+      "build_only": true,
+      "minimal": false
+    }
+  ]
+}

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

@@ -0,0 +1,12 @@
+{
+  "platform": "windows/amd64",
+  "runner": ["self-hosted", "Windows", "dev-box-windows-2026"],
+  "configs": [
+    { "build_type": "Release", "minimal": true },
+    {
+      "build_type": "Debug",
+      "build_only": true,
+      "minimal": false
+    }
+  ]
+}

.github/scripts/telemetry/check_bucket_parity.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Assert the C++ millisecond ladder agrees with the collector's spanmetrics ladder.
+
+The two are specified to match so a span-derived latency panel and a native
+histogram panel can be read on the same scale. Nothing else couples them, so
+extending one ladder alone -- sub-millisecond edges below 1ms, second-scale
+edges up to 30s -- silently leaves the other short. That failure is quiet:
+Prometheus returns the second-highest edge for a quantile landing in the
+`+Inf` bucket, so every quantile above a too-low ceiling reads back as a flat
+number that looks like a measurement rather than an error. This check is what
+makes the drift loud.
+
+The rule is containment, not equality:
+
+  * every representable collector edge MUST appear in the C++ ladder, so the
+    shared range reads identically;
+  * the C++ ladder MAY carry extra edges ABOVE the collector's highest edge,
+    because jobs outlive spans -- the updatepaths job type was measured
+    averaging ~60s, which no span approaches. Demanding equality would force a
+    ceiling that censors it, recreating the failure this guards against;
+  * collector edges below 1ms are expected to be ABSENT rather than missing:
+    beast::insight::Event rounds every duration up to a whole millisecond
+    before it reaches the histogram, so those edges could never collect a
+    sample.
+
+Exit 0 when the ladders agree, 1 with a diff when they do not.
+"""
+
+import re
+import sys
+from pathlib import Path
+
+HEADER = Path("include/xrpl/telemetry/HistogramBuckets.h")
+COLLECTOR = Path("docker/telemetry/otel-collector-config.yaml")
+
+# beast::insight::Event applies ceil<milliseconds>, so anything below 1ms
+# collapses onto the 1ms edge.
+REPRESENTABLE_FLOOR_MS = 1.0
+
+UNIT_TO_MS = {"ms": 1.0, "s": 1000.0}
+
+
+def collector_edges_ms():
+    """Parse the spanmetrics bucket list, normalising each edge to milliseconds."""
+    text = COLLECTOR.read_text()
+    match = re.search(r"buckets:\s*\[(.*?)\]", text, re.S)
+    if not match:
+        sys.exit(f"{COLLECTOR}: no 'buckets:' list found")
+
+    edges = []
+    for raw in match.group(1).split(","):
+        token = raw.strip()
+        if not token:
+            continue
+        parsed = re.fullmatch(r"([0-9.]+)(ms|s)", token)
+        if not parsed:
+            sys.exit(f"{COLLECTOR}: cannot parse bucket edge {token!r}")
+        edges.append(float(parsed.group(1)) * UNIT_TO_MS[parsed.group(2)])
+    return edges
+
+
+def cpp_edges_ms():
+    """Parse kMillisecondBuckets out of the header that owns every ladder."""
+    text = HEADER.read_text()
+    match = re.search(r"kMillisecondBuckets\{(.*?)\};", text, re.S)
+    if not match:
+        sys.exit(f"{HEADER}: kMillisecondBuckets not found")
+    return [
+        float(token.strip().replace("'", ""))
+        for token in match.group(1).split(",")
+        if token.strip()
+    ]
+
+
+def main():
+    collector = collector_edges_ms()
+    cpp = cpp_edges_ms()
+    required = [edge for edge in collector if edge >= REPRESENTABLE_FLOOR_MS]
+    if not required:
+        sys.exit(f"{COLLECTOR}: no edges at or above {REPRESENTABLE_FLOOR_MS} ms")
+    collector_top = max(required)
+
+    missing = [edge for edge in required if edge not in cpp]
+    # An extra C++ edge inside the collector's range means the two scales
+    # disagree where they overlap. Above the collector's top it is a deliberate
+    # extension.
+    inside_range = [e for e in cpp if e not in required and e < collector_top]
+
+    if not missing and not inside_range:
+        extensions = [e for e in cpp if e > collector_top]
+        summary = f"OK: all {len(required)} representable collector edges present"
+        if extensions:
+            pretty = ", ".join(f"{e:g}" for e in extensions)
+            summary += (
+                f"; {len(extensions)} extension edge(s) above "
+                f"{collector_top:g} ms: [{pretty}]"
+            )
+        print(summary)
+        return 0
+
+    print("Bucket ladder parity violated.", file=sys.stderr)
+    print(
+        f"  collector (>= {REPRESENTABLE_FLOOR_MS:g} ms): "
+        f"{[f'{e:g}' for e in required]}",
+        file=sys.stderr,
+    )
+    print(
+        f"  HistogramBuckets.h            : {[f'{e:g}' for e in cpp]}", file=sys.stderr
+    )
+    for edge in missing:
+        print(f"  MISSING from the C++ ladder: {edge:g} ms", file=sys.stderr)
+    for edge in inside_range:
+        print(
+            f"  C++ edge {edge:g} ms lies inside the collector's range but is not "
+            "a collector edge -- add it to the collector or drop it here",
+            file=sys.stderr,
+        )
+    print(
+        "\nThe two ladders must agree over their shared range. Extra C++ edges are\n"
+        "permitted only ABOVE the collector's highest edge. To re-price the shared\n"
+        f"range, edit the ladder in {HEADER} and the\n"
+        f"spanmetrics 'buckets:' list in {COLLECTOR}\n"
+        "in the same change, so both sides stay in step.",
+        file=sys.stderr,
+    )
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/scripts/telemetry/check_regression_bounds.py

@@ -0,0 +1,496 @@
+#!/usr/bin/env python3
+"""Assert every workload-gate absolute bound is the one its own baseline implies.
+
+The regression gate in ``docker/telemetry/workload`` fails CI when a span or
+job-queue quantile grows. Whether it *can* fail is decided by
+``regression-thresholds.json``, and that file's numbers are derived from
+``baselines/baseline-timings.json`` plus the two histogram ladders. Nothing
+tied the three together, and the gate has now been broken three times by the
+same class of drift:
+
+  1. the microsecond ladder's floor moved 100us -> 1us, voiding every
+     job_queue baseline captured before it;
+  2. the spanmetrics ladder's floor moved 1ms -> 0.01ms, voiding every
+     sub-millisecond span baseline captured before it;
+  3. the absolute bounds stayed calibrated for a 5-25ms band the spans had
+     left, so a 100x regression on ``span.ledger.store.p95`` reported zero
+     regressions and exit 0.
+
+Each time the gate stayed green, which is indistinguishable from a passing
+build. Documentation did not prevent recurrence, so this is a check.
+
+The rule it enforces is the one recorded in ``regression-thresholds.json``
+under ``_absolute_bound_derivation``: for a baseline sitting in the half-open
+bucket ``(lo, hi]`` of its ladder, with ``hi_next`` the next edge above ``hi``,
+
+    max_abs_increase_* == hi_next - baseline
+
+so the gate trips only when the reading clears the bucket *above* the
+baseline's own. Six rules are checked:
+
+  A  the baseline's key set equals the surface ``regression-metrics.json``
+     declares (a stale key left behind reads as covered but never gates);
+  B  every gated key has a per-metric override, not a fallback default;
+  C  each absolute bound equals ``hi_next - baseline``;
+  D  each percentage bound stays below ``100 * bound / baseline``, so the
+     absolute bound remains the operative half of the ``AND`` -- the span
+     ladder's 2s/3s/4s edges are only 1.25x-1.5x apart, where this silently
+     stops being true;
+  E  no baseline carries the ladder-floor signature ``quantile x first_edge``,
+     which means every sample landed in the first bucket and the number is
+     interpolation arithmetic rather than a latency;
+  F  every entry in ``excluded_keys`` names a key the surface would otherwise
+     declare, carries a reason, and has neither a threshold override nor a
+     baseline value left behind.
+
+Rule A subtracts ``excluded_keys`` from BOTH sides of its comparison, so a
+quantile removed from the gated set neither reads as a missing baseline nor as
+an undeclared one -- an exclusion left in the baseline is one failure, rule F's,
+which names the file to edit. Rule F is what keeps that subtraction honest: an
+exclusion is the one edit here that makes the gate cover LESS, so a stale or
+misspelt entry must fail rather than silently widen itself.
+
+A PLACEHOLDER baseline -- ``"placeholder": true`` or an empty ``metrics``
+object -- exits 0, because that is the documented bootstrap state and CI has to
+stay green while a baseline is being recaptured. A missing, unreadable or
+malformed input is a different thing and exits 1: a check that reports success
+without having checked anything is the same green-build-that-is-not failure this
+script exists to prevent, so renaming or deleting one of its inputs must not
+silence it.
+
+A baseline ENTRY that is not an object, or whose value is not a positive finite
+number, is rejected before any rule runs -- see ``check_key`` and
+``_unusable_baseline``. Every rule does arithmetic on that value,
+and a degenerate one made the script crash with a traceback (rule D divides by
+it) or emit advice about the wrong file (a negative value inverts rule D's
+comparison). Reporting malformed input is what this script is for, so it must
+name the key rather than die on it.
+
+Exit 0 when every rule holds, 1 with per-key detail otherwise.
+"""
+
+import json
+import math
+import re
+import sys
+from pathlib import Path
+
+WORKLOAD = Path("docker/telemetry/workload")
+BASELINE = WORKLOAD / "baselines/baseline-timings.json"
+THRESHOLDS = WORKLOAD / "regression-thresholds.json"
+METRICS = WORKLOAD / "regression-metrics.json"
+COLLECTOR = Path("docker/telemetry/otel-collector-config.yaml")
+HEADER = Path("include/xrpl/telemetry/HistogramBuckets.h")
+
+UNIT_TO_MS = {"ms": 1.0, "s": 1000.0}
+# A bound may differ from the derived value only by double round-tripping.
+REL_TOLERANCE = 1e-12
+
+
+def is_number(value):
+    """True for a real JSON number. bool is an int subclass, so exclude it."""
+    return not isinstance(value, bool) and isinstance(value, (int, float))
+
+
+def read_text_or_exit(path):
+    """Read a required text input, or exit 1 naming the input that failed."""
+    try:
+        return path.read_text()
+    except OSError as exc:
+        sys.exit(f"{path}: required input could not be read -- {exc}")
+
+
+def read_json_or_exit(path):
+    """Read and parse a required JSON object, or exit 1 naming what failed.
+
+    All three JSON inputs are objects. A top-level null, list or number parses
+    fine and then dies on the first .get, so check the shape here rather than
+    report it as a traceback pointing into this script.
+    """
+    try:
+        parsed = json.loads(read_text_or_exit(path))
+    except json.JSONDecodeError as exc:
+        sys.exit(f"{path}: required input is not valid JSON -- {exc}")
+    if not isinstance(parsed, dict):
+        sys.exit(
+            f"{path}: required input is valid JSON but its top level is "
+            f"{type(parsed).__name__}, not an object -- nothing can be read from it"
+        )
+    return parsed
+
+
+def span_edges_ms():
+    """Parse the spanmetrics bucket list, normalising each edge to milliseconds."""
+    match = re.search(r"buckets:\s*\[(.*?)\]", read_text_or_exit(COLLECTOR), re.S)
+    if not match:
+        sys.exit(f"{COLLECTOR}: no 'buckets:' list found")
+    edges = []
+    for raw in match.group(1).split(","):
+        token = raw.strip()
+        if not token:
+            continue
+        parsed = re.fullmatch(r"([0-9.]+)(ms|s)", token)
+        if not parsed:
+            sys.exit(f"{COLLECTOR}: cannot parse bucket edge {token!r}")
+        edges.append(float(parsed.group(1)) * UNIT_TO_MS[parsed.group(2)])
+    return edges
+
+
+def microsecond_edges():
+    """Parse kMicrosecondBuckets out of the header that owns every ladder."""
+    match = re.search(r"kMicrosecondBuckets\{(.*?)\};", read_text_or_exit(HEADER), re.S)
+    if not match:
+        sys.exit(f"{HEADER}: kMicrosecondBuckets not found")
+    return [
+        float(token.strip().replace("'", ""))
+        for token in match.group(1).split(",")
+        if token.strip()
+    ]
+
+
+def declared_keys(metrics_cfg):
+    """Rebuild the flat key set regression-metrics.json declares.
+
+    Deliberately reimplemented rather than imported from ``prom_queries.py``,
+    which pulls in aiohttp; CI telemetry checks stay dependency-free. The key
+    format is fixed by that file's own ``_key_format`` field.
+
+    ``excluded_keys`` is NOT subtracted here: rule F needs the full product to
+    tell a real exclusion from a misspelt one. Callers that want the gated
+    surface subtract it themselves.
+    """
+    keys = set()
+    spans = metrics_cfg.get("spans", {})
+    for name in spans.get("names", []):
+        for quantile in spans.get("_quantiles", []):
+            keys.add(f"span.{name}.p{_quantile_label(quantile)}")
+    jobs = metrics_cfg.get("job_queue", {})
+    for name in jobs.get("names", []):
+        for phase in jobs.get("_phases", []):
+            for quantile in jobs.get("_quantiles", []):
+                keys.add(f"job.{name}.{phase}.p{_quantile_label(quantile)}")
+    return keys
+
+
+def _quantile_label(quantile):
+    """0.95 -> '95', 0.5 -> '50', matching capture_timings.py's key format."""
+    return f"{quantile * 100:g}".replace(".", "")
+
+
+def brackets(value, edges):
+    """Return ``(lo, hi, hi_next)`` for the bucket ``(lo, hi]`` holding value."""
+    padded = [0.0] + list(edges)
+    for i in range(1, len(padded)):
+        if value <= padded[i]:
+            hi_next = padded[i + 1] if i + 1 < len(padded) else None
+            return padded[i - 1], padded[i], hi_next
+    return None, None, None
+
+
+def resolve_override(key, thresholds):
+    """Return the override rule for a key, or None if it falls back to defaults."""
+    group, quantile = key.rsplit(".", 1)
+    return thresholds.get("overrides", {}).get(group, {}).get(quantile)
+
+
+def check_exclusions(metrics_cfg, thresholds, baseline_metrics, declared):
+    """Apply rule F to every entry in ``excluded_keys``.
+
+    An exclusion is the only edit to this config that makes the gate cover
+    LESS, so each entry has to prove it is deliberate and complete:
+
+      * it names a key the names x quantiles product would otherwise declare,
+        so a typo or a stale entry surviving a surface change is caught rather
+        than silently subtracting nothing;
+      * it carries a non-empty reason, because "why is this not gated" is the
+        question a future maintainer will ask and prose is the only answer;
+      * no threshold override and no baseline value are left behind, since
+        either would read as gated to anyone grepping for the key.
+
+    Args:
+        metrics_cfg:      Parsed regression-metrics.json.
+        thresholds:       Parsed regression-thresholds.json.
+        baseline_metrics: The baseline's ``metrics`` map.
+        declared:         Output of declared_keys(), before exclusions come off.
+
+    Returns:
+        A list of failure strings, empty when every entry is well formed.
+    """
+    failures = []
+    for key, reason in sorted(metrics_cfg.get("excluded_keys", {}).items()):
+        if key not in declared:
+            failures.append(
+                f"{key}: listed in excluded_keys but not produced by the "
+                f"names x quantiles product, so it subtracts nothing -- fix the "
+                f"spelling or drop the entry (rule F)"
+            )
+            continue
+        if not isinstance(reason, str) or not reason.strip():
+            failures.append(
+                f"{key}: excluded with no reason. Record why it is not gated, "
+                f"with the measurement behind it (rule F)"
+            )
+        if resolve_override(key, thresholds) is not None:
+            failures.append(
+                f"{key}: excluded but still has a threshold override, which "
+                f"reads as gated -- remove it from {THRESHOLDS} (rule F)"
+            )
+        if key in baseline_metrics:
+            failures.append(
+                f"{key}: excluded but still has a baseline value, so rule A "
+                f"would pass while nothing gates it -- remove it from "
+                f"{BASELINE} (rule F)"
+            )
+    return failures
+
+
+def _unusable_baseline(key, value, unit):
+    """Reject a baseline value no rule below could evaluate, or None if it is fine.
+
+    Every rule downstream does arithmetic on this number, and two of them break
+    on a degenerate one rather than reporting it:
+
+      * rule D computes ``100 * bound / value``, which raises
+        ZeroDivisionError on ``0.0``. The script then dies with a traceback
+        instead of naming the key -- a validator that crashes where it should
+        report is the same green-build-that-is-not failure in reverse;
+      * a NEGATIVE value makes that same ratio negative, so ``pct >= ratio`` is
+        true for any configured percentage and rule D fires with a message
+        telling the maintainer to lower ``max_pct_increase``. The advice is
+        wrong: the fault is the baseline, not the threshold;
+      * a non-numeric value raises TypeError inside rule E's subtraction.
+
+    Rule E does not cover the zero case, which is easy to assume it does: its
+    test ``abs(value - quantile * first_edge) <= 1e-9 * first_edge`` reduces to
+    ``quantile <= 1e-9`` when value is ``0.0``, and that is false for every
+    quantile this harness captures (0.5, 0.95, 0.99).
+
+    None of these arise from the normal pipeline -- ``histogram_quantile`` over
+    a first-bucket-only histogram returns ``quantile x first_edge``, never zero,
+    and rule E is the guard for exactly that. They arise from a hand-edited or
+    truncated baseline, which is precisely the input this script exists to
+    reject.
+
+    Args:
+        key:   Flat metric key, for the message.
+        value: The baseline value as read from the file.
+        unit:  The entry's unit, for the message.
+
+    Returns:
+        A failure string, or None when the value is usable.
+    """
+    # bool is a subclass of int; True would otherwise pass as the number 1.
+    if not is_number(value):
+        return (
+            f"{key}: baseline value {value!r} is not a number, so no bound can be "
+            f"derived from it. Recapture the baseline from a CI run rather than "
+            f"editing it by hand -- see baselines/README.md"
+        )
+    if not math.isfinite(value) or value <= 0:
+        return (
+            f"{key}: baseline is {value!r}{unit}, but a captured latency quantile "
+            f"is strictly positive and finite. A zero baseline leaves the "
+            f"percentage bound undefined, a negative one inverts it, and neither "
+            f"can bracket to a bucket -- so no rule below can be evaluated. "
+            f"Recapture the baseline from a CI run rather than editing it by hand "
+            f"-- see baselines/README.md"
+        )
+    return None
+
+
+def check_key(key, entry, thresholds, ladders):
+    """Apply rules B, C, D and E to one gated key. Returns a list of failures.
+
+    The rules assume the baseline entry holds a strictly positive, finite
+    number, which is what ``histogram_quantile`` yields. Anything else is
+    malformed input, and reporting malformed input is this script's whole job,
+    so it is rejected up front rather than arithmetic being attempted on it --
+    see ``_unusable_baseline``.
+
+    The entry's SHAPE is checked first, for the same reason. A hand edit that
+    writes the bare number instead of the ``{"value": .., "unit": ..}`` object
+    leaves no ``.get`` to call, and the script died with an AttributeError
+    traceback naming a line in itself rather than the key at fault.
+    """
+    if not isinstance(entry, dict):
+        return [
+            f"{key}: baseline entry {entry!r} is not an object carrying value and "
+            f"unit, so no bound can be derived from it. Recapture the baseline "
+            f"from a CI run rather than editing it by hand -- see "
+            f"baselines/README.md"
+        ]
+
+    value, unit = entry.get("value"), entry.get("unit", "")
+    edges = ladders.get(unit)
+    if value is None or edges is None:
+        return [f"{key}: baseline has no value, or unknown unit {unit!r}"]
+
+    unusable = _unusable_baseline(key, value, unit)
+    if unusable:
+        return [unusable]
+
+    failures = []
+    first_edge = edges[0]
+    quantile = int(key.rsplit(".p", 1)[1]) / 100.0
+    if abs(value - quantile * first_edge) <= 1e-9 * first_edge:
+        failures.append(
+            f"{key}: baseline {value!r} equals quantile {quantile:g} x the ladder "
+            f"floor {first_edge:g}{unit}, so every sample landed in the first "
+            f"bucket and this is bucket arithmetic, not a latency. No absolute "
+            f"bound can gate it -- add a finer ladder edge or drop the metric "
+            f"from {METRICS} (rule E)"
+        )
+        return failures
+
+    _, _, hi_next = brackets(value, edges)
+    if hi_next is None:
+        return [
+            f"{key}: baseline {value!r}{unit} sits in or above the ladder's top "
+            f"bucket, so there is no hi_next to derive a bound from -- extend the "
+            f"ladder (rule C)"
+        ]
+
+    rule = resolve_override(key, thresholds)
+    if rule is None:
+        failures.append(
+            f"{key}: no per-metric override, so it falls back to the defaults and "
+            f"gates on the percentage bound alone. Add an override in "
+            f"{THRESHOLDS} with "
+            f"max_abs_increase_{unit} = {hi_next - value!r} (rule B)"
+        )
+        return failures
+
+    if not isinstance(rule, dict):
+        return [
+            f"{key}: threshold override {rule!r} is not an object carrying "
+            f"max_abs_increase_{unit} and max_pct_increase -- fix it in {THRESHOLDS}"
+        ]
+
+    bound = rule.get("max_abs_increase_ms", rule.get("max_abs_increase_us"))
+    if bound is not None and not is_number(bound):
+        return [
+            f"{key}: max_abs_increase_{unit} is {bound!r}, not a number, so it "
+            f"cannot be compared with the derived bound -- fix it in {THRESHOLDS}"
+        ]
+    expected = hi_next - value
+    if bound is None or abs(bound - expected) > REL_TOLERANCE * expected:
+        failures.append(
+            f"{key}: absolute bound is {bound!r}, expected {expected!r} "
+            f"(hi_next {hi_next:g} - baseline {value!r}) (rule C)"
+        )
+
+    pct = rule.get("max_pct_increase")
+    if pct is None:
+        failures.append(f"{key}: no max_pct_increase, so the metric never gates")
+    elif not is_number(pct):
+        failures.append(
+            f"{key}: max_pct_increase is {pct!r}, not a number -- fix it in "
+            f"{THRESHOLDS}"
+        )
+    elif bound is not None and pct >= 100.0 * bound / value:
+        failures.append(
+            f"{key}: max_pct_increase {pct:g}% is at or above the absolute bound's "
+            f"{100.0 * bound / value:.1f}% of baseline, so the percentage bound "
+            f"becomes the operative one and the bucket guarantee is lost. Lower it "
+            f"or document the metric as percentage-gated (rule D)"
+        )
+    return failures
+
+
+def main():
+    missing = [
+        p for p in (BASELINE, THRESHOLDS, METRICS, COLLECTOR, HEADER) if not p.exists()
+    ]
+    if missing:
+        print("Cannot check workload regression bounds.", file=sys.stderr)
+        for path in missing:
+            print(f"  {path}: required input is absent", file=sys.stderr)
+        print(
+            "\nA missing input is not a reason to pass. Deleting or renaming one of\n"
+            "these would otherwise leave the gate reporting success without having\n"
+            "checked a single bound -- the failure this script exists to prevent. If\n"
+            "the workload harness has genuinely moved, update the paths here.",
+            file=sys.stderr,
+        )
+        return 1
+
+    baseline = read_json_or_exit(BASELINE)
+    thresholds = read_json_or_exit(THRESHOLDS)
+    metrics_cfg = read_json_or_exit(METRICS)
+
+    if baseline.get("placeholder") is True or not baseline.get("metrics"):
+        print("OK: baseline is a placeholder, bounds cannot be derived yet")
+        return 0
+
+    ladders = {"ms": span_edges_ms(), "us": microsecond_edges()}
+    gated = baseline["metrics"]
+    # A list or a string is truthy, so it survives the placeholder test above
+    # and then either crashes or reports its characters as gated keys.
+    if not isinstance(gated, dict):
+        sys.exit(
+            f"{BASELINE}: 'metrics' is {type(gated).__name__}, not an object of "
+            f"key -> {{value, unit}} -- recapture the baseline from a CI run"
+        )
+    failures = []
+
+    declared = declared_keys(metrics_cfg)
+    failures.extend(check_exclusions(metrics_cfg, thresholds, gated, declared))
+    # Rule A compares against the GATED surface, so a deliberately excluded
+    # quantile is not reported as a baseline that was never captured.
+    #
+    # The same keys come off rule A's over-coverage side too. An excluded key
+    # left in the baseline is rule F's finding, reported with the file to edit;
+    # rule A would add a second failure for the same single mistake, saying the
+    # key is not declared -- which is not even true, it is declared and then
+    # excluded. Only exclusions the surface really declares are subtracted, so a
+    # misspelt exclusion naming a stale baseline key still reaches rule A.
+    excluded_declared = set(metrics_cfg.get("excluded_keys", {})) & declared
+    declared -= excluded_declared
+    for key in sorted(set(gated) - declared - excluded_declared):
+        failures.append(
+            f"{key}: in the baseline but not declared by {METRICS}, so it is "
+            f"reported every run and can never gate -- remove it (rule A)"
+        )
+    for key in sorted(declared - set(gated)):
+        failures.append(
+            f"{key}: declared by {METRICS} but absent from the baseline, so it "
+            f"never gates -- capture a baseline for it (rule A)"
+        )
+
+    for key in sorted(gated):
+        if key in declared:
+            failures.extend(check_key(key, gated[key], thresholds, ladders))
+
+    if not failures:
+        excluded = metrics_cfg.get("excluded_keys", {})
+        print(
+            f"OK: {len(gated)} gated key(s); every absolute bound equals "
+            f"hi_next - baseline, every key has an override, and the absolute "
+            f"bound is the operative half of the AND for all of them"
+        )
+        # Printed, not silent: an exclusion narrows the gate, so the count
+        # belongs in the CI log where a reviewer sees it without opening a file.
+        if excluded:
+            print(
+                f"    {len(excluded)} declared key(s) deliberately not gated: "
+                f"{', '.join(sorted(excluded))} (see excluded_keys in {METRICS})"
+            )
+        return 0
+
+    print(
+        "Workload regression bounds are not derived from the baseline.", file=sys.stderr
+    )
+    for failure in failures:
+        print(f"  {failure}", file=sys.stderr)
+    print(
+        f"\nThe rule is recorded in {THRESHOLDS} under _absolute_bound_derivation:\n"
+        "a bound is hi_next - baseline, where hi_next is the edge above the top of\n"
+        "the bucket holding the baseline. Refreshing a baseline therefore obliges\n"
+        "you to re-derive its bound; see baselines/README.md.",
+        file=sys.stderr,
+    )
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/scripts/telemetry/test_check_regression_bounds.py

@@ -0,0 +1,462 @@
+#!/usr/bin/env python3
+"""Tests for check_regression_bounds.py.
+
+The checker reads five files by path relative to the working directory, so each
+test assembles a scratch tree holding copies of the real inputs, mutates one
+thing, and runs the checker as a subprocess there. Testing the real entry point
+is deliberate: the contract under test is the exit code CI reads, and an
+in-process call would not exercise it.
+
+Two groups:
+
+* the input-handling contract -- a placeholder baseline must PASS because that
+  is the documented bootstrap state, while a missing, unreadable or malformed
+  input must FAIL. A checker that returns success without having checked
+  anything is the failure this whole gate exists to prevent;
+* one case per rule (A to F), so a rule that stops flagging is caught.
+
+stdlib unittest only; the repo installs no third-party runner for CI.
+"""
+
+import json
+import os
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+CHECKER = SCRIPT_DIR / "check_regression_bounds.py"
+REPO = SCRIPT_DIR.parents[2]
+
+WORKLOAD = "docker/telemetry/workload"
+BASELINE = f"{WORKLOAD}/baselines/baseline-timings.json"
+THRESHOLDS = f"{WORKLOAD}/regression-thresholds.json"
+METRICS = f"{WORKLOAD}/regression-metrics.json"
+COLLECTOR = "docker/telemetry/otel-collector-config.yaml"
+HEADER = "include/xrpl/telemetry/HistogramBuckets.h"
+INPUTS = (BASELINE, THRESHOLDS, METRICS, COLLECTOR, HEADER)
+
+
+class CheckerCase(unittest.TestCase):
+    """Base class giving each test an isolated copy of the checker's inputs."""
+
+    def setUp(self):
+        self.tree = Path(tempfile.mkdtemp())
+        # Bound to THIS tree, not read off self.tree when the cleanup finally
+        # runs. A test that calls setUp again for a fresh tree (see the
+        # degenerate-baseline subTests) rebinds self.tree, and a late read would
+        # make every registered cleanup remove the LAST tree, leaving each
+        # earlier one behind in /tmp.
+        self.addCleanup(self._cleanup, self.tree)
+        for rel in INPUTS:
+            dest = self.tree / rel
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(REPO / rel, dest)
+        script = self.tree / ".github/scripts/telemetry/check_regression_bounds.py"
+        script.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(CHECKER, script)
+
+    def _cleanup(self, tree):
+        """Remove one scratch tree, restoring permissions rmtree needs first."""
+        for path in tree.rglob("*"):
+            if path.is_file():
+                path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+        shutil.rmtree(tree, ignore_errors=True)
+
+    def run_checker(self):
+        """Run the checker in the scratch tree, returning (code, stdout+stderr)."""
+        proc = subprocess.run(
+            [sys.executable, ".github/scripts/telemetry/check_regression_bounds.py"],
+            cwd=self.tree,
+            capture_output=True,
+            text=True,
+        )
+        return proc.returncode, proc.stdout + proc.stderr
+
+    def edit_json(self, rel, mutate):
+        """Load a scratch input, hand it to mutate(), write it back."""
+        path = self.tree / rel
+        data = json.loads(path.read_text())
+        mutate(data)
+        path.write_text(json.dumps(data, indent=2))
+
+    def read_json(self, rel):
+        """Read a scratch input without modifying it."""
+        return json.loads((self.tree / rel).read_text())
+
+    def gated(self, key):
+        """Return ``(baseline_value, configured_bound)`` for one gated key.
+
+        Read from the scratch copies of the real inputs rather than written as
+        literals, because a literal here is a copy of one particular baseline:
+        a hard-coded figure breaks the moment the baseline is refreshed, which is
+        the very drift check_regression_bounds.py exists to catch. Deriving the
+        figure keeps the assertion pinned to the rule instead of to a snapshot.
+        """
+        group, quantile = key.rsplit(".", 1)
+        rule = self.read_json(THRESHOLDS)["overrides"][group][quantile]
+        bound = rule.get("max_abs_increase_ms", rule.get("max_abs_increase_us"))
+        return self.read_json(BASELINE)["metrics"][key]["value"], bound
+
+
+class TestInputHandling(CheckerCase):
+    """A placeholder passes; a missing or broken input must not."""
+
+    def test_unmodified_tree_passes(self):
+        code, out = self.run_checker()
+        self.assertEqual(code, 0, out)
+        self.assertIn("gated key(s)", out)
+
+    def test_placeholder_flag_passes(self):
+        self.edit_json(BASELINE, lambda d: d.update(placeholder=True))
+        code, out = self.run_checker()
+        self.assertEqual(code, 0, out)
+        self.assertIn("placeholder", out)
+
+    def test_empty_metrics_baseline_passes(self):
+        self.edit_json(BASELINE, lambda d: d.update(metrics={}))
+        code, out = self.run_checker()
+        self.assertEqual(code, 0, out)
+        self.assertIn("placeholder", out)
+
+    def test_missing_baseline_fails_naming_the_input(self):
+        (self.tree / BASELINE).unlink()
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("baseline-timings.json", out)
+
+    def test_missing_collector_config_fails_naming_the_input(self):
+        (self.tree / COLLECTOR).unlink()
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("otel-collector-config.yaml", out)
+
+    @unittest.skipIf(os.geteuid() == 0, "root ignores the read permission bit")
+    def test_unreadable_baseline_fails(self):
+        (self.tree / BASELINE).chmod(0)
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("baseline-timings.json", out)
+        self.assertIn("could not be read", out)
+        self.assertNotIn("Traceback", out)
+
+    def test_malformed_baseline_json_fails(self):
+        (self.tree / BASELINE).write_text("{ not json")
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("valid JSON", out)
+
+    def test_malformed_thresholds_json_fails(self):
+        (self.tree / THRESHOLDS).write_text("]")
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("valid JSON", out)
+
+    def test_non_object_top_level_fails_naming_the_input(self):
+        """Valid JSON of the wrong shape must be named, not raise a traceback.
+
+        A top-level null, list or number parses, so it reaches the first .get
+        and dies pointing at a line in the checker rather than at the file the
+        operator has to fix.
+        """
+        for rel, text in (
+            (BASELINE, "null"),
+            (THRESHOLDS, "[]"),
+            (METRICS, "5"),
+        ):
+            with self.subTest(input=rel):
+                self.setUp()
+                (self.tree / rel).write_text(text)
+                code, out = self.run_checker()
+                self.assertEqual(code, 1, out)
+                self.assertIn(rel, out)
+                self.assertIn("not an object", out)
+                self.assertNotIn("Traceback", out)
+
+    def test_non_object_metrics_map_fails_naming_the_input(self):
+        """A string 'metrics' is truthy, so it slips past the placeholder test.
+
+        Left unchecked it reports the string's own characters as gated keys,
+        which is worse than a crash: the advice is wrong rather than absent.
+        An empty map still has to pass, because that is the bootstrap state.
+        """
+        self.edit_json(BASELINE, lambda d: d.update(metrics="span.tx.process.p99"))
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("'metrics' is str", out)
+        self.assertNotIn("Traceback", out)
+
+        self.setUp()
+        self.edit_json(BASELINE, lambda d: d.update(metrics={}))
+        code, out = self.run_checker()
+        self.assertEqual(code, 0, out)
+
+
+class TestRules(CheckerCase):
+    """One case per rule, so a rule that stops flagging is caught."""
+
+    def test_rule_a_flags_baseline_key_not_declared(self):
+        self.edit_json(
+            BASELINE,
+            lambda d: d["metrics"].update(
+                {"span.rpc.process.p99": {"unit": "ms", "value": 9.0}}
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule A)", out)
+
+    def test_rule_a_flags_declared_key_without_baseline(self):
+        self.edit_json(METRICS, lambda d: d["spans"]["names"].append("consensus.round"))
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule A)", out)
+
+    def test_rule_b_flags_missing_override(self):
+        self.edit_json(THRESHOLDS, lambda d: d["overrides"].pop("span.ledger.build"))
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule B)", out)
+
+    def test_rule_b_names_the_unit_suffixed_key(self):
+        """The key it tells the operator to add must be the key the code reads.
+
+        The bound is stored as max_abs_increase_ms or _us. A message naming a
+        bare max_abs_increase sends the operator to add a key nothing reads, so
+        the gate keeps failing with no explanation. Both suffixes are covered,
+        because a test on the ms side alone passes on a hard-coded "_ms".
+        """
+        for group, suffix in (
+            ("span.ledger.build", "max_abs_increase_ms"),
+            ("job.transaction.queued", "max_abs_increase_us"),
+        ):
+            with self.subTest(group=group):
+                self.setUp()
+                self.edit_json(THRESHOLDS, lambda d: d["overrides"].pop(group))
+                code, out = self.run_checker()
+                self.assertEqual(code, 1, out)
+                self.assertIn("(rule B)", out)
+                self.assertIn(suffix, out)
+                self.assertNotIn("max_abs_increase =", out)
+
+    def test_non_numeric_threshold_is_reported_not_crashed(self):
+        """A hand-edited bound that is a string must be named, not raise."""
+        self.edit_json(
+            THRESHOLDS,
+            lambda d: d["overrides"]["span.ledger.build"]["p95"].update(
+                max_abs_increase_ms="5.5"
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("not a number", out)
+        self.assertNotIn("Traceback", out)
+
+    def test_rule_c_flags_rounded_bound(self):
+        """A bound rounded for readability is still not the derived bound."""
+        _, exact = self.gated("span.tx.process.p99")
+        rounded = round(exact, 4)
+        self.assertNotEqual(rounded, exact, "pick a key whose bound rounds visibly")
+        self.edit_json(
+            THRESHOLDS,
+            lambda d: d["overrides"]["span.tx.process"]["p99"].update(
+                max_abs_increase_ms=rounded
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule C)", out)
+
+    def test_rule_c_accepts_bound_within_relative_tolerance(self):
+        """The tolerance is 1e-12 relative, not exact equality."""
+        _, exact = self.gated("span.tx.process.p99")
+        self.edit_json(
+            THRESHOLDS,
+            lambda d: d["overrides"]["span.tx.process"]["p99"].update(
+                max_abs_increase_ms=exact * (1 + 5e-13)
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 0, out)
+
+    def test_rule_d_flags_percentage_bound_becoming_operative(self):
+        """Rule D trips at exactly 100 x bound / baseline, its ``>=`` boundary."""
+        baseline, bound = self.gated("span.tx.apply.p99")
+        boundary = 100.0 * bound / baseline
+        self.edit_json(
+            THRESHOLDS,
+            lambda d: d["overrides"]["span.tx.apply"]["p99"].update(
+                max_pct_increase=boundary
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule D)", out)
+
+    def test_rule_d_accepts_percentage_bound_just_below_the_boundary(self):
+        """The other side of rule D's boundary, so the test cannot pass vacuously."""
+        baseline, bound = self.gated("span.tx.apply.p99")
+        boundary = 100.0 * bound / baseline
+        self.edit_json(
+            THRESHOLDS,
+            lambda d: d["overrides"]["span.tx.apply"]["p99"].update(
+                max_pct_increase=boundary * (1 - 1e-9)
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 0, out)
+
+    def test_rule_a_ignores_an_excluded_key(self):
+        """An excluded key must not read as a baseline that was never captured.
+
+        The unmodified tree already exercises this — span.ledger.validate p95
+        and p99 are declared by the names x quantiles product, excluded, and
+        absent from the baseline — so this asserts the subtraction is what makes
+        it pass, by naming the keys in the reported exclusion line.
+        """
+        code, out = self.run_checker()
+        self.assertEqual(code, 0, out)
+        self.assertIn("span.ledger.validate.p95", out)
+        self.assertIn("deliberately not gated", out)
+
+    def test_rule_f_flags_exclusion_that_subtracts_nothing(self):
+        """A misspelt or stale exclusion silently narrows nothing — catch it."""
+        self.edit_json(
+            METRICS,
+            lambda d: d["excluded_keys"].update({"span.ledger.validate.p97": "typo"}),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule F)", out)
+        self.assertIn("subtracts nothing", out)
+
+    def test_rule_f_flags_exclusion_without_a_reason(self):
+        self.edit_json(
+            METRICS,
+            lambda d: d["excluded_keys"].update({"span.ledger.validate.p95": "   "}),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule F)", out)
+        self.assertIn("no reason", out)
+
+    def test_rule_f_flags_override_left_behind(self):
+        """An excluded key still carrying a bound reads as gated."""
+        self.edit_json(
+            THRESHOLDS,
+            lambda d: d["overrides"]["span.ledger.validate"].update(
+                {"p95": {"max_pct_increase": 50.0, "max_abs_increase_ms": 0.25}}
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule F)", out)
+        self.assertIn("still has a threshold override", out)
+
+    def test_rule_f_flags_baseline_value_left_behind(self):
+        """Excluded but still in the baseline: rule A passes, nothing gates."""
+        self.edit_json(
+            BASELINE,
+            lambda d: d["metrics"].update(
+                {"span.ledger.validate.p95": {"unit": "ms", "value": 0.24}}
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule F)", out)
+        self.assertIn("still has a baseline value", out)
+
+    # A key that is GATED, so seeding it exercises the numeric guard rather than
+    # rule F. It must not be one of the excluded keys: putting a value there
+    # trips "excluded but still has a baseline value" first and the test would
+    # pass for the wrong reason.
+    DEGENERATE_KEY = "span.tx.process.p50"
+
+    def _seed_degenerate_baseline(self, value):
+        """Replace one gated key's baseline value with an unusable one.
+
+        The threshold is deliberately left alone. The numeric guard runs before
+        every rule, so no bound arrangement is needed to reach it -- and on the
+        pre-fix checker this same seeding still reached the crash, because rule C
+        appends its failure and falls through to rule D's division.
+        """
+        key = self.DEGENERATE_KEY
+        self.assertNotIn(
+            key,
+            self.read_json(METRICS).get("excluded_keys", {}),
+            "DEGENERATE_KEY must be gated, not excluded",
+        )
+        self.edit_json(
+            BASELINE,
+            lambda d: d["metrics"].update({key: {"unit": "ms", "value": value}}),
+        )
+
+    def test_degenerate_baseline_is_reported_not_crashed(self):
+        """A zero, negative or non-numeric baseline must NAME the key, not raise.
+
+        Rule D computes ``100 * bound / value``, so a 0.0 baseline used to exit
+        via ZeroDivisionError and a traceback, and a negative one used to emit a
+        rule-D failure blaming ``max_pct_increase`` when the fault was the
+        baseline. Rule E does not cover the zero case: its test reduces to
+        ``quantile <= 1e-9`` there, false for every quantile captured.
+        """
+        # Asserting the guard's OWN wording, not merely "exit 1 with no
+        # traceback": the negative and bool cases already exited 1 without a
+        # traceback before the fix, by emitting a rule-D failure that blamed the
+        # wrong file. A looser assertion passes on that and proves nothing.
+        cases = (
+            (0.0, "strictly positive"),
+            (-1.0, "strictly positive"),
+            (float("nan"), "strictly positive"),
+            (float("inf"), "strictly positive"),
+            ("0.006", "is not a number"),
+            (True, "is not a number"),
+        )
+        for value, expected in cases:
+            with self.subTest(value=value):
+                self.setUp()  # a clean scratch tree per value
+                self._seed_degenerate_baseline(value)
+                code, out = self.run_checker()
+                self.assertEqual(code, 1, out)
+                self.assertNotIn("Traceback", out)
+                self.assertIn(self.DEGENERATE_KEY, out)
+                self.assertIn(expected, out)
+                # The old rule-D message told the maintainer to lower the
+                # percentage bound; the baseline is what is wrong.
+                self.assertNotIn("(rule D)", out)
+
+    def test_rule_e_flags_ladder_floor_signature(self):
+        """ledger.store's quantiles were the ladder floor times the quantile."""
+        store = {"p50": 0.005, "p95": 0.0095, "p99": 0.0099}
+        self.edit_json(METRICS, lambda d: d["spans"]["names"].append("ledger.store"))
+        self.edit_json(
+            BASELINE,
+            lambda d: d["metrics"].update(
+                {
+                    f"span.ledger.store.{q}": {"unit": "ms", "value": v}
+                    for q, v in store.items()
+                }
+            ),
+        )
+        self.edit_json(
+            THRESHOLDS,
+            lambda d: d["overrides"].update(
+                {
+                    "span.ledger.store": {
+                        q: {"max_pct_increase": 50.0, "max_abs_increase_ms": 0.05 - v}
+                        for q, v in store.items()
+                    }
+                }
+            ),
+        )
+        code, out = self.run_checker()
+        self.assertEqual(code, 1, out)
+        self.assertIn("(rule E)", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,66 @@
+name: Build `nix` Docker images
+
+on:
+  push:
+    branches:
+      - develop
+    paths:
+      - "flake.nix"
+      - "flake.lock"
+      - "rust-toolchain.toml"
+      - "nix/**"
+      - "!nix/docker/README.md"
+      - "!nix/devshell.nix"
+      - "!nix/check-tools/**"
+      - "bin/default-loader-path.sh"
+      - "bin/install-sanitizer-libs.sh"
+  pull_request:
+    paths:
+      - ".github/workflows/build-nix-images.yml"
+      - "flake.nix"
+      - "flake.lock"
+      - "rust-toolchain.toml"
+      - "nix/**"
+      - "!nix/docker/README.md"
+      - "!nix/devshell.nix"
+      - "!nix/check-tools/**"
+      - "bin/check-tools.sh"
+      - "bin/default-loader-path.sh"
+      - "bin/install-sanitizer-libs.sh"
+  workflow_dispatch:
+
+concurrency:
+  # Read `on-trigger.yml` for the rationale behind this concurrency group name.
+  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:
+  build-merge:
+    name: Build and push `nix-${{ matrix.distro.name }}` image
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      fail-fast: false
+      matrix:
+        # The base images are the oldest supported version of each distro
+        # that we want to build images for.
+        distro:
+          - name: nixos
+            base_image: nixos/nix:latest
+          - name: ubuntu
+            base_image: ubuntu:20.04
+          - name: debian
+            base_image: debian:bookworm
+          - name: rhel
+            base_image: registry.access.redhat.com/ubi9/ubi:latest
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
+    with:
+      image_name: xrpld/nix-${{ matrix.distro.name }}
+      dockerfile: nix/docker/Dockerfile
+      base_image: ${{ matrix.distro.base_image }}
+      push: ${{ github.event_name == 'push' }}

.github/workflows/build-packaging-images.yml

@@ -0,0 +1,49 @@
+name: Build `packaging` Docker images
+
+on:
+  push:
+    branches:
+      - develop
+    paths:
+      - ".github/workflows/build-packaging-images.yml"
+      - "bin/install-packaging-tools.sh"
+      - "package/docker/**"
+  pull_request:
+    paths:
+      - ".github/workflows/build-packaging-images.yml"
+      - "bin/install-packaging-tools.sh"
+      - "package/docker/**"
+  workflow_dispatch:
+
+concurrency:
+  # Read `on-trigger.yml` for the rationale behind this concurrency group name.
+  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:
+  build-merge:
+    name: Build and push `packaging-${{ matrix.distro.name }}` image
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      fail-fast: false
+      matrix:
+        # Newest of each distro: these images only wrap pre-built binaries, so
+        # they set no floor for consumers. build_pkg.py pins the RPM dist tag.
+        distro:
+          - name: debian
+            base_image: debian:trixie
+          # AlmaLinux rather than UBI, which does not ship rpm-sign.
+          - name: rhel
+            base_image: almalinux:10
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
+    with:
+      image_name: xrpld/packaging-${{ matrix.distro.name }}
+      dockerfile: package/docker/Dockerfile
+      base_image: ${{ matrix.distro.base_image }}
+      push: ${{ github.event_name == 'push' }}

.github/workflows/build-pre-commit-image.yml

@@ -0,0 +1,38 @@
+name: Build `pre-commit` Docker image
+
+on:
+  push:
+    branches:
+      - develop
+    paths:
+      - ".github/workflows/build-pre-commit-image.yml"
+      - "bin/pre-commit/Dockerfile"
+      - "rust-toolchain.toml"
+  pull_request:
+    paths:
+      - ".github/workflows/build-pre-commit-image.yml"
+      - "bin/pre-commit/Dockerfile"
+      - "rust-toolchain.toml"
+  workflow_dispatch:
+
+concurrency:
+  # Read `on-trigger.yml` for the rationale behind this concurrency group name.
+  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:
+  build-merge:
+    name: Build and push `pre-commit` image
+    permissions:
+      contents: read
+      packages: write
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
+    with:
+      image_name: xrpld/pre-commit
+      dockerfile: bin/pre-commit/Dockerfile
+      base_image: ubuntu:26.04
+      push: ${{ github.event_name == 'push' }}

.github/workflows/cargo-audit.yml

@@ -0,0 +1,80 @@
+name: Cargo audit
+
+on:
+  schedule:
+    # 06:32 UTC every Monday.
+    - cron: "32 6 * * 1"
+  push:
+    branches:
+      - "develop"
+      - "release/*"
+    paths:
+      - "crates/**/Cargo.toml"
+      - "crates/Cargo.lock"
+      - ".github/workflows/cargo-audit.yml"
+  pull_request:
+    paths:
+      - "crates/**/Cargo.toml"
+      - "crates/Cargo.lock"
+      - ".github/workflows/cargo-audit.yml"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+    working-directory: crates
+
+permissions:
+  contents: read
+
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
+    permissions:
+      contents: read
+      # Needed to open an issue on scheduled failures.
+      issues: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Run cargo audit
+        id: audit
+        continue-on-error: true
+        run: |
+          set -o pipefail
+          cargo audit | tee /tmp/cargo-audit.txt
+
+      - name: Prepare issue body
+        if: ${{ steps.audit.outcome != 'success' && github.event_name == 'schedule' }}
+        run: |
+          {
+              echo "## \`cargo audit\` found advisories"
+              echo
+              echo '```'
+              cat /tmp/cargo-audit.txt
+              echo '```'
+              echo
+              echo "---"
+              echo "*This issue was automatically created by the cargo-audit workflow.*"
+          } >/tmp/cargo-audit-issue.md
+
+      - name: Create issue
+        if: ${{ steps.audit.outcome != 'success' && github.event_name == 'schedule' }}
+        uses: XRPLF/actions/create-issue@2b8bc36af85b88bca0dd7bfac2e2dc05f94ad712
+        with:
+          title: "cargo audit found vulnerabilities"
+          body_file: /tmp/cargo-audit-issue.md
+          labels: "Bug,Security"
+
+      - name: Fail if advisories were found
+        if: ${{ steps.audit.outcome != 'success' }}
+        run: |
+          echo "cargo audit found advisories!"
+          cat /tmp/cargo-audit.txt
+          exit 1

.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,39 @@
+name: Check PR description
+
+on:
+  merge_group:
+    types:
+      - checks_requested
+  pull_request:
+    types:
+      - opened
+      - edited
+      - reopened
+      - synchronize
+      - ready_for_review
+    branches:
+      - develop
+      - "release-*"
+      - "release/*"
+      - "staging/*"
+
+jobs:
+  check_description:
+    if: ${{ github.event.pull_request.draft != true }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - 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,23 @@
+name: Check PR title
+
+on:
+  merge_group:
+    types:
+      - checks_requested
+  pull_request:
+    types:
+      - opened
+      - edited
+      - reopened
+      - synchronize
+      - ready_for_review
+    branches:
+      - develop
+      - "release-*"
+      - "release/*"
+      - "staging/*"
+
+jobs:
+  check_title:
+    if: ${{ github.event.pull_request.draft != true }}
+    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@d7c65e49225a38f6d8010eacf017bb5a98d7476c

.github/workflows/check-tools.yml

@@ -0,0 +1,114 @@
+# Verifies the committed snapshots of `bin/check-tools.sh` output for each Nix
+# environment (see nix/check-tools/). If the environment changes — a new image
+# tag, an updated flake.lock, a different tool list — without the matching
+# snapshot being regenerated and committed, this workflow fails so the drift is
+# caught in review.
+#
+# To regenerate the snapshots, see nix/check-tools/README.md.
+name: Check tools
+
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/check-tools.yml"
+      - ".github/scripts/strategy-matrix/linux.json"
+      - "bin/check-tools.sh"
+      - "nix/**"
+      - "flake.nix"
+      - "flake.lock"
+      - "rust-toolchain.toml"
+  push:
+    branches:
+      - "develop"
+    paths:
+      - ".github/workflows/check-tools.yml"
+      - ".github/scripts/strategy-matrix/linux.json"
+      - "bin/check-tools.sh"
+      - "nix/**"
+      - "flake.nix"
+      - "flake.lock"
+      - "rust-toolchain.toml"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  # The nix-nixos image tag is pinned alongside the build matrix in linux.json,
+  # so snapshots are checked against the exact image CI builds against.
+  linux-image-tag:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Read nix image tag
+        id: tag
+        run: echo "tag=$(jq -r .image_tag .github/scripts/strategy-matrix/linux.json)" >>"${GITHUB_OUTPUT}"
+
+  # One job for all environments; they differ only in whether the tools come
+  # from the nix-nixos container (Linux) or `nix develop` (macOS).
+  check-tools:
+    needs: linux-image-tag
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-latest
+            snapshot: nix/check-tools/nix-ubuntu-amd64.txt
+            nix_develop: false
+          - runner: ubuntu-24.04-arm
+            snapshot: nix/check-tools/nix-ubuntu-arm64.txt
+            nix_develop: false
+          - runner: macos-26-apple-clang-21
+            snapshot: nix/check-tools/macos.txt
+            nix_develop: true
+    runs-on: ${{ matrix.runner }}
+    # Linux runs inside the pinned nix-nixos image; macOS runs natively and uses
+    # the flake's dev shell instead (see the run step below).
+    container: ${{ !matrix.nix_develop && format('ghcr.io/xrplf/xrpld/nix-ubuntu:{0}', needs.linux-image-tag.outputs.tag) || null }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        with:
+          enable_ccache: false
+
+      - name: Regenerate snapshot
+        env:
+          CHECK_TOOLS_SKIP_CLONE: "1"
+          # check-tools.sh skips some macOS tools when CI is set; the snapshots
+          # capture the full `nix develop` environment, so unset it here.
+          CI: ""
+        run: |
+          if [ "${{ matrix.nix_develop }}" = "true" ]; then
+              # `nix develop` prints the dev-shell greeting first; keep only the
+              # check-tools.sh output (from the "Detected OS:" line onward).
+              nix --extra-experimental-features "nix-command flakes" develop \
+                  -c bash bin/check-tools.sh | sed -n '/^Detected OS:/,$p' >"${{ matrix.snapshot }}"
+          else
+              bash bin/check-tools.sh >"${{ matrix.snapshot }}"
+          fi
+
+      - name: Verify snapshot is up to date
+        run: |
+          if ! git diff --exit-code -- "${{ matrix.snapshot }}"; then
+              echo "::error::${{ matrix.snapshot }} is out of date. Regenerate it (see nix/check-tools/README.md) and commit the result."
+              exit 1
+          fi
+
+      - name: Upload regenerated snapshot
+        if: failure()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: check-tools-${{ runner.os }}-${{ runner.arch }}
+          path: ${{ matrix.snapshot }}

.github/workflows/clang-format.yml

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

.github/workflows/conflicting-pr.yml

@@ -0,0 +1,26 @@
+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:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'IgnoreConflicts') }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if PRs are dirty
+        uses: eps1lon/actions-label-merge-conflict@0273be72a0bbd58fcd71d0d6c02c209b50d1e5e1 # v3.1.0
+        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/doxygen.yml

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

.github/workflows/levelization.yml

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

.github/workflows/libxrpl.yml

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

.github/workflows/macos.yml

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

.github/workflows/missing-commits.yml

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

.github/workflows/nix.yml

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

.github/workflows/on-pr.yml

@@ -0,0 +1,322 @@
+# This workflow runs workflows to check, build and test the project
+# on every meaningful change on pull_request.
+# However, it will not run if the PR is a draft
+# unless it has the 'DraftRunCI' or 'Full CI build' label.
+#
+# By default a PR builds only a minimal matrix.
+# The full matrix runs once the PR is labeled "Ready to merge" or "Full CI build".
+# 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
+      # Trigger on label changes so toggling "Ready to merge" or "Full CI build"
+      # switches between the minimal and full matrix without needing a new push.
+      - labeled
+      - unlabeled
+
+concurrency:
+  # A single per-ref group with cancel-in-progress means any newer run (a push
+  # or a label change) supersedes the in-progress one for that ref. Keeping
+  # exactly one authoritative run per ref ensures a fast do-nothing run can never
+  # mask a real build's checks.
+  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 at all,
+  # based on the current set of labels: it runs when the PR is not a draft
+  # (which should also cover merge-group) or has the 'DraftRunCI' or
+  # 'Full CI build' label. Whether a build then happens, and whether it is the
+  # minimal or full matrix, is decided further below and in the strategy matrix.
+  should-run:
+    if: >-
+      ${{
+        !github.event.pull_request.draft
+        || contains(github.event.pull_request.labels.*.name, 'DraftRunCI')
+        || contains(github.event.pull_request.labels.*.name, 'Full CI build')
+      }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - 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/otel-naming/**
+            .github/scripts/rename/**
+            .github/scripts/telemetry/**
+            .github/workflows/reusable-check-levelization.yml
+            .github/workflows/reusable-check-otel-naming.yml
+            .github/workflows/reusable-check-rename.yml
+            .github/workflows/on-pr.yml
+
+            # The non-code layers the OTel naming check validates: the docs that
+            # publish attribute tables (Rule E) and the telemetry stack config —
+            # collector, Tempo, dashboards (Rules B, C, D). Without these paths a
+            # docs-only or dashboard-only pull request sets `go=false`, so the
+            # very layers those rules exist to police would never be checked.
+            # As with `README.md` below, matching one of these also switches on
+            # the rest of the workflow; there is a single `go` gate.
+            docs/**
+            docker/telemetry/**
+
+            # Keep the paths below in sync with those in `on-trigger.yml`.
+            .github/actions/build-deps/**
+            .github/actions/release-info/**
+            .github/actions/setup-conan/**
+            .github/actions/setup-nix-env/**
+            .github/scripts/strategy-matrix/**
+            .github/workflows/reusable-build-test-config.yml
+            .github/workflows/reusable-build-test.yml
+            .github/workflows/reusable-check-autogen.yml
+            .github/workflows/reusable-clang-tidy.yml
+            .github/workflows/reusable-package-test-install.yml
+            .github/workflows/reusable-package.yml
+            .github/workflows/reusable-rust.yml
+            .github/workflows/reusable-strategy-matrix.yml
+            .github/workflows/reusable-test.yml
+            .github/workflows/reusable-upload-recipe.yml
+            .clang-tidy
+            .codecov.yml
+            bin/check-nix-store-refs.sh
+            bin/check-tools.sh
+            bin/default-loader-path.sh
+            cfg/**
+            cmake/**
+            conan/**
+            crates/**
+            external/**
+            include/**
+            src/**
+            tests/**
+            CMakeLists.txt
+            conanfile.py
+            conan.lock
+            flake.lock
+            flake.nix
+            nix/**
+            LICENSE.md
+            package/**
+            README.md
+
+      - name: Determine changed telemetry files
+        # A separate list from the one above, because the telemetry validation
+        # builds xrpld on the self-hosted runner and then runs a multi-node
+        # cluster for up to 30 minutes. The `go` gate above is true for almost
+        # any pull request, so gating this one on `go` alone would run that cost
+        # on every pull request in the repository.
+        #
+        # Keep these globs pointing at paths that exist -- two earlier entries
+        # matched zero tracked files, so C++ telemetry changes never triggered.
+        id: telemetry-changes
+        uses: tj-actions/changed-files@9426d40962ed5378910ee2e21d5f8c6fcbf2dd96 # v47.0.6
+        with:
+          files: |
+            # This workflow, the one it calls, and the harness that runs.
+            .github/workflows/on-pr.yml
+            .github/workflows/reusable-telemetry-validation.yml
+            docker/telemetry/**
+
+            # The telemetry modules themselves.
+            include/xrpl/telemetry/**
+            src/libxrpl/telemetry/**
+            src/xrpld/telemetry/**
+
+            # beast::insight, whose gauges and counters the validation asserts
+            # on. Both halves: the interface headers decide what the OTel
+            # collector can publish, so editing one moves the metric surface as
+            # surely as editing the implementation does.
+            include/xrpl/beast/insight/**
+            src/libxrpl/beast/insight/**
+
+            # The span-name and metric-name constants. These are the wire
+            # contract the harness asserts against by literal string, so a
+            # rename here compiles cleanly and silently empties the assertions.
+            # Matched by filename rather than directory because the convention
+            # colocates each header with the class it serves: they live under
+            # consensus/, overlay/, app/ledger/, app/main/, app/misc/, rpc/ and
+            # tx/, not under a telemetry/ directory.
+            **/*SpanNames.h
+            **/*MetricNames.h
+
+            # The GTests that pin those same constants.
+            src/tests/libxrpl/telemetry/**
+
+            # The checkers that gate this surface. otel-naming derives the legal
+            # attribute and metric names from the headers above; the telemetry
+            # scripts enforce the histogram-bucket parity and regression-bound
+            # rules the harness depends on.
+            .github/scripts/otel-naming/**
+            .github/scripts/telemetry/**
+
+            # The recipe, because it carries the telemetry option this decides
+            # the validation on.
+            conanfile.py
+
+      - 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 PR is labeled "Full CI build" (draft or not)
+        # * 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') }}
+          FULL: ${{ contains(github.event.pull_request.labels.*.name, 'Full CI build') }}
+          MERGE: ${{ github.event_name == 'merge_group' }}
+        run: |
+          echo "go=${{ (env.DRAFT != 'true' && env.READY == 'true') || env.FULL == 'true' || env.FILES == 'true' || env.MERGE == 'true' }}" >>"${GITHUB_OUTPUT}"
+          cat "${GITHUB_OUTPUT}"
+    outputs:
+      go: ${{ steps.go.outputs.go == 'true' }}
+      telemetry_changed: ${{ steps.telemetry-changes.outputs.any_changed == 'true' }}
+
+  check-autogen:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-check-autogen.yml
+
+  check-levelization:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-check-levelization.yml
+
+  check-otel-naming:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-check-otel-naming.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:
+      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 }}
+
+  rust:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-rust.yml
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  package:
+    needs: [should-run, build-test]
+    # Packaging consumes the debian/rhel release binaries, which are only built
+    # by the full matrix. Skip it for pull requests that ran only the minimal
+    # matrix (i.e. not yet labeled "Ready to merge" or "Full CI build").
+    if: ${{ needs.should-run.outputs.go == 'true' && (github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'Ready to merge') || contains(github.event.pull_request.labels.*.name, 'Full CI build')) }}
+    uses: ./.github/workflows/reusable-package.yml
+    with:
+      # A pull request builds packages to prove they still build, and publishes
+      # nothing. Stated rather than left to the input's default, so that changing
+      # that default cannot start publishing from pull requests. No secrets are
+      # passed either, which is the second reason a publish here cannot succeed.
+      publish: false
+
+  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.NEXUS_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+
+  telemetry-validation:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' && needs.should-run.outputs.telemetry_changed == 'true' }}
+    uses: ./.github/workflows/reusable-telemetry-validation.yml
+
+  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-autogen
+      - check-levelization
+      - check-otel-naming
+      - check-rename
+      - clang-tidy
+      - build-test
+      - rust
+      - package
+      - upload-recipe
+      - notify-clio
+      - telemetry-validation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fail
+        run: exit 1

.github/workflows/on-tag.yml

@@ -0,0 +1,52 @@
+# When a versioned tag is pushed, this workflow:
+#
+#   - uploads the libxrpl recipe to the Conan remote
+#   - builds and tests the release binaries
+#   - builds the DEB and RPM packages
+#   - publishes those packages to the XRPLF package repositories
+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.NEXUS_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+
+  build-test:
+    if: ${{ github.repository_owner == 'XRPLF' }}
+    uses: ./.github/workflows/reusable-build-test.yml
+    strategy:
+      fail-fast: true
+      matrix:
+        os: [linux]
+    with:
+      ccache_enabled: false
+      os: ${{ matrix.os }}
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  package:
+    if: ${{ github.repository_owner == 'XRPLF' }}
+    needs: build-test
+    uses: ./.github/workflows/reusable-package.yml
+    with:
+      publish: true
+    secrets:
+      remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+      signing_key: ${{ secrets.NEXUS_PACKAGES_PRIVATE_KEY }}

.github/workflows/on-trigger.yml

@@ -0,0 +1,131 @@
+# 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/release-info/**"
+      - ".github/actions/setup-conan/**"
+      - ".github/actions/setup-nix-env/**"
+      - ".github/scripts/strategy-matrix/**"
+      - ".github/workflows/reusable-build-test-config.yml"
+      - ".github/workflows/reusable-build-test.yml"
+      - ".github/workflows/reusable-check-autogen.yml"
+      - ".github/workflows/reusable-clang-tidy.yml"
+      - ".github/workflows/reusable-package-test-install.yml"
+      - ".github/workflows/reusable-package.yml"
+      - ".github/workflows/reusable-rust.yml"
+      - ".github/workflows/reusable-strategy-matrix.yml"
+      - ".github/workflows/reusable-test.yml"
+      - ".github/workflows/reusable-upload-recipe.yml"
+      - ".clang-tidy"
+      - ".codecov.yml"
+      - "bin/check-nix-store-refs.sh"
+      - "bin/check-tools.sh"
+      - "bin/default-loader-path.sh"
+      - "cfg/**"
+      - "cmake/**"
+      - "conan/**"
+      - "crates/**"
+      - "external/**"
+      - "include/**"
+      - "src/**"
+      - "tests/**"
+      - "CMakeLists.txt"
+      - "conanfile.py"
+      - "conan.lock"
+      - "flake.lock"
+      - "flake.nix"
+      - "nix/**"
+      - "LICENSE.md"
+      - "package/**"
+      - "README.md"
+
+  # 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:
+  check-autogen:
+    uses: ./.github/workflows/reusable-check-autogen.yml
+
+  clang-tidy:
+    uses: ./.github/workflows/reusable-clang-tidy.yml
+    permissions:
+      issues: write
+      contents: read
+    with:
+      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 }}
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  rust:
+    uses: ./.github/workflows/reusable-rust.yml
+    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.NEXUS_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+
+  package:
+    needs: build-test
+    uses: ./.github/workflows/reusable-package.yml
+    with:
+      # Packages are built on every trigger; only develop pushes in XRPLF/rippled
+      # publish them, matching upload-recipe above.
+      publish: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
+    secrets:
+      remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+      signing_key: ${{ secrets.NEXUS_PACKAGES_PRIVATE_KEY }}

.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@279ec358f4a1be4088be3e024b07916fa97c75b6
+    with:
+      runs_on: ubuntu-latest
+      container: '{ "image": "ghcr.io/xrplf/xrpld/pre-commit:sha-473fe44" }'

.github/workflows/publish-docs.yml

@@ -0,0 +1,94 @@
+# This workflow builds the documentation for the repository, and publishes it to
+# GitHub Pages when changes are merged into the default branch.
+name: Build and publish documentation
+
+on:
+  push:
+    branches:
+      - "develop"
+    paths:
+      - ".github/workflows/publish-docs.yml"
+      - "*.md"
+      - "**/*.md"
+      - "docs/**"
+      - "include/**"
+      - "src/libxrpl/**"
+      - "src/xrpld/**"
+  pull_request:
+    paths:
+      - ".github/workflows/publish-docs.yml"
+      - "*.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/xrpld/nix-ubuntu:sha-060957e
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        with:
+          enable_ccache: false
+
+      - name: Get number of processors
+        uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
+        id: nproc
+        with:
+          subtract: ${{ env.NPROC_SUBTRACT }}
+
+      - name: Print build environment
+        uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574
+
+      - name: Check Doxygen version
+        run: doxygen --version
+
+      - name: Build documentation
+        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: 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@368f82528645a54fb793d4d04e342629a3f51346 # v5.0.1

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

@@ -0,0 +1,451 @@
+name: Build and test configuration
+
+on:
+  workflow_call:
+    inputs:
+      benchmark:
+        description: "Whether to smoke-run the benchmarks after testing."
+        required: false
+        type: boolean
+        default: false
+
+      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: ""
+
+      compiler:
+        description: 'The compiler to use ("gcc" or "clang"). Leave empty for macOS/Windows (uses system default).'
+        required: false
+        type: string
+        default: ""
+
+      toolchain:
+        description: 'Where the toolchain comes from ("nix" to build the flake CI environment on the runner, empty for the system one). macOS only: Linux always builds in a Nix image, and Nix has no Windows support.'
+        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 || 180 }}
+    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, voidstar and validator-keys should be enabled.
+      COVERAGE_ENABLED: ${{ contains(inputs.cmake_args, '-Dcoverage=ON') }}
+      VOIDSTAR_ENABLED: ${{ contains(inputs.cmake_args, '-Dvoidstar=ON') }}
+      VALIDATOR_KEYS_ENABLED: ${{ contains(inputs.cmake_args, '-Dvalidator_keys=ON') }}
+      SANITIZERS_ENABLED: ${{ inputs.sanitizers != '' }}
+      # The binaries reusable-package.yml consumes. A private repository skips
+      # them except on a tag push, which is what produces its release packages.
+      PACKAGING_ARTIFACTS_ENABLED: ${{ github.event.repository.visibility == 'public' || startsWith(github.ref, 'refs/tags/') }}
+    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@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        with:
+          enable_ccache: ${{ inputs.ccache_enabled }}
+
+      # Before any step that uses a build tool, composite actions included.
+      - name: Setup Nix environment
+        if: ${{ inputs.toolchain == 'nix' }}
+        uses: ./.github/actions/setup-nix-env
+
+      - name: Set ccache log file
+        if: ${{ inputs.ccache_enabled && runner.debug == '1' }}
+        run: echo "CCACHE_LOGFILE=${{ runner.temp }}/ccache.log" >>"${GITHUB_ENV}"
+
+      - name: Check tools
+        env:
+          CHECK_TOOLS_SKIP_CLONE: "1"
+        run: ./bin/check-tools.sh || true
+
+      - 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: Set compiler environment (Linux)
+        if: ${{ runner.os == 'Linux' }}
+        uses: ./.github/actions/set-compiler-env
+        with:
+          compiler: ${{ inputs.compiler }}
+
+      - name: Use cargo artifacts cache
+        uses: ./.github/actions/cargo-cache
+        with:
+          cache-directories: ${{ env.BUILD_DIR }}/corrosion
+          key: ${{ inputs.config_name }}
+          # two workspaces here because build artifacts are located in 2 places:
+          # - crates/target when cargo is called directly
+          # - build/cargo when cargo is called by cmake
+          workspaces: |
+            crates
+            crates -> ${{ runner.os == 'Windows' && format('../{0}/x64/{1}/cargo', env.BUILD_DIR, inputs.build_type) || format('../{0}/cargo', env.BUILD_DIR) }}
+
+      # `setup-nix-env` already did this for the Nix toolchain.
+      - name: Setup Conan
+        if: ${{ inputs.toolchain != 'nix' }}
+        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 18 2026' || 'Ninja' }}' \
+              -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+              -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+              ${CMAKE_ARGS} \
+              ..
+
+      # Export the sanitizer options before any instrumented binary runs. The
+      # build step below invokes instrumented dependency tools (protoc, grpc),
+      # so setting UBSAN_OPTIONS here lets the UBSan suppression list silence
+      # their diagnostics too, not just at test time.
+      # GITHUB_WORKSPACE (not the github.workspace context) is used so the path
+      # resolves correctly inside the container job.
+      - name: Set sanitizer options
+        if: ${{ !inputs.build_only && env.SANITIZERS_ENABLED == 'true' }}
+        env:
+          CONFIG_NAME: ${{ inputs.config_name }}
+        run: |
+          SUPP="${GITHUB_WORKSPACE}/sanitizers/suppressions"
+          ASAN_OPTS="include=${SUPP}/runtime-asan-options.txt:suppressions=${SUPP}/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=${SUPP}/runtime-tsan-options.txt:suppressions=${SUPP}/tsan.supp" >>${GITHUB_ENV}
+          echo "UBSAN_OPTIONS=include=${SUPP}/runtime-ubsan-options.txt:suppressions=${SUPP}/ubsan.supp" >>${GITHUB_ENV}
+          echo "LSAN_OPTIONS=include=${SUPP}/runtime-lsan-options.txt:suppressions=${SUPP}/lsan.supp" >>${GITHUB_ENV}
+
+      - name: Build the binary
+        working-directory: ${{ env.BUILD_DIR }}
+        env:
+          BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
+          BUILD_TYPE: ${{ inputs.build_type }}
+          CMAKE_TARGET: ${{ inputs.cmake_target }}
+        run: |
+          set -o pipefail
+          cmake \
+              --build . \
+              --config "${BUILD_TYPE}" \
+              --parallel "${BUILD_NPROC}" \
+              --target "${CMAKE_TARGET}" \
+              2>&1 | tee "${GITHUB_WORKSPACE}/build.log"
+
+      # Nothing may reference the store, so whole trees are checked - the Conan
+      # cache included, since what it holds is what gets uploaded and reused.
+      - name: Check the build output for Nix store references (Nix toolchain)
+        if: ${{ inputs.toolchain == 'nix' }}
+        run: ./bin/check-nix-store-refs.sh "${BUILD_DIR}"
+
+      - name: Check the Conan cache for Nix store references (Nix toolchain)
+        if: ${{ inputs.toolchain == 'nix' }}
+        run: ./bin/check-nix-store-refs.sh "${CONAN_HOME}"
+
+      # Only what PatchNixBinary.cmake retargets: the toolchain in the Linux
+      # images always references the store. Same condition it uses.
+      - name: Check for Nix store references (Linux)
+        if: ${{ runner.os == 'Linux' && env.SANITIZERS_ENABLED == 'false' }}
+        run: |
+          ./bin/check-nix-store-refs.sh "${BUILD_DIR}/xrpld"
+          ./bin/check-nix-store-refs.sh "${BUILD_DIR}/xrpl_tests"
+
+      - 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: ${{ env.PACKAGING_ARTIFACTS_ENABLED == 'true' && 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: Run the validator-keys tests
+        if: ${{ env.VALIDATOR_KEYS_ENABLED == 'true' }}
+        working-directory: ${{ env.BUILD_DIR }}
+        run: ./validator-keys --unittest
+
+      - name: Upload the validator-keys binary
+        if: ${{ env.PACKAGING_ARTIFACTS_ENABLED == 'true' && env.VALIDATOR_KEYS_ENABLED == 'true' }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: validator-keys-${{ inputs.config_name }}
+          path: |
+            ${{ env.BUILD_DIR }}/validator-keys
+            ${{ env.BUILD_DIR }}/validator-keys-LICENSE
+          retention-days: 3
+          if-no-files-found: error
+
+      - name: Upload the test binary (Linux)
+        if: ${{ github.event.repository.visibility == 'public' && runner.os == 'Linux' }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: xrpl_tests-${{ inputs.config_name }}
+          path: ${{ env.BUILD_DIR }}/xrpl_tests
+          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 == 'ubuntu-gcc-debug-amd64-coverage' }}
+        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: Run the separate tests
+        if: ${{ !inputs.build_only }}
+        working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
+        run: ./xrpl_tests
+
+      - 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))
+
+          # The resolver/preload workaround is only correct for the ASan build:
+          # a regular build doesn't hit the __dn_expand interceptor bug, and must
+          # NOT have libasan injected. So only preload when xrpld is ASan-built.
+          #
+          # libresolv hosts getaddrinfo's resolver helpers (dn_expand, res_*). Under ASan
+          # these are intercepted via dlsym(RTLD_NEXT, ...), which yields a NULL pointer
+          # and crashes DNS resolution if libresolv isn't loaded. Linking it guarantees
+          # the symbols are present; it's a harmless no-op on glibc >= 2.34 (merged into
+          # libc) and is what the compiler driver already does for sanitizer builds.
+          #   https://github.com/llvm/llvm-project/issues/59007
+          #   https://github.com/google/sanitizers/issues/1592
+          if ldd ./xrpld | grep -q libasan; then
+              PRELOAD="$(gcc -print-file-name=libasan.so):/usr/lib/x86_64-linux-gnu/libresolv.so.2"
+          else
+              PRELOAD=""
+          fi
+
+          LD_PRELOAD="$PRELOAD" ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee "${GITHUB_WORKSPACE}/unittest.log"
+
+      - name: Run Rust tests
+        if: ${{ !inputs.build_only }}
+        working-directory: crates
+        run: cargo nextest run --workspace --all-features --locked --no-tests=warn
+
+      # Smoke-run every benchmark module with a single repetition to confirm the
+      # benchmarks still build and execute. This is a correctness check, not a
+      # performance measurement, so there is nothing to gain from repeating it
+      # across configurations: it is opted into by a single config in the
+      # strategy matrix (see the 'benchmark' flag in the JSON files), which
+      # keeps it off instrumented builds (sanitizers/coverage/voidstar), where
+      # it would be slow and meaningless, off Debug builds, where it is much
+      # slower, and off Windows, where the `install` target does not build them.
+      - name: Run the benchmarks
+        if: ${{ inputs.benchmark }}
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          rc=0
+          while IFS= read -r bench; do
+              echo "::group::${bench}"
+              "./${bench}" --benchmark_repetitions=1 || rc=1
+              echo "::endgroup::"
+          done < <(find src/benchmarks -type f -perm -u+x -name 'xrpl.bench.*')
+          exit "${rc}"
+
+      - name: Show build/test failure summary
+        if: ${{ failure() }}
+        run: |
+          cd "${GITHUB_WORKSPACE}"
+
+          if [ -f unittest.log ]; then
+              if ! grep -E "failed" unittest.log | grep -vE "^I[0-9]|^[0-9]+> (ERR:|FTL:)"; then
+                  echo "unittest.log present but no failure lines found."
+              fi
+          elif [ -f build.log ]; then
+              # GCC/Clang emit "error:" (covers "fatal error:"); MSVC emits
+              # "error C####:", "error LNK####:", and "fatal error LNK####:".
+              # -A6 prints the lines that follow each match (source line, caret,
+              # notes, and the "N errors generated" tally) to capture the whole
+              # diagnostic block.
+              if ! grep -E -A6 "error:|error C[0-9]{4}|error LNK[0-9]{4}|fatal error" build.log; then
+                  echo "build.log present but no compile errors found."
+              fi
+          else
+              echo "unittest.log/build.log not found; something went wrong."
+              exit 1
+          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_owner == 'XRPLF' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
+        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
+        with:
+          disable_search: true
+          disable_telem: true
+          fail_ci_if_error: true
+          files: ${{ env.BUILD_DIR }}/coverage.xml
+          flags: cpp
+          plugins: noop
+          token: ${{ secrets.CODECOV_TOKEN }}
+          verbose: true

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

@@ -0,0 +1,56 @@
+# 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
+
+    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 }}
+
+  # 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) }}
+    with:
+      benchmark: ${{ matrix.benchmark }}
+      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: ${{ matrix.image || '' }}
+      config_name: ${{ matrix.config_name }}
+      sanitizers: ${{ matrix.sanitizers }}
+      compiler: ${{ matrix.compiler || '' }}
+      toolchain: ${{ matrix.toolchain || '' }}
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

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

@@ -0,0 +1,76 @@
+# This workflow checks that the generated protocol wrapper classes are
+# up-to-date with the macro files and generator scripts they are produced from,
+# see more info in include/xrpl/protocol_autogen/README.md.
+name: Check autogen
+
+# This workflow can only be triggered by other workflows.
+on: workflow_call
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-autogen
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  BUILD_DIR: build/codegen
+
+jobs:
+  autogen:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.13"
+
+      # Code generation is pure Python, so the standalone project below offers
+      # the same targets as the main build without needing its dependencies or
+      # a compiler, which keeps this job down to a few seconds.
+      - name: Configure CMake
+        run: cmake -S cmake/codegen -B "${BUILD_DIR}"
+
+      - name: Install code generation dependencies
+        run: cmake --build "${BUILD_DIR}" --target setup_code_gen
+
+      - name: Generate code
+        run: cmake --build "${BUILD_DIR}" --target code_gen
+
+      - name: Check for differences
+        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.
+
+            Run the following from the repository root, then commit and push
+            the regenerated files. This needs neither the dependencies nor a
+            compiler. See include/xrpl/protocol_autogen/README.md for more info.
+
+              cmake -S cmake/codegen -B build/codegen
+              cmake --build build/codegen --target setup_code_gen
+              cmake --build build/codegen --target code_gen
+
+            In an already configured build directory, the 'setup_code_gen' and
+            'code_gen' targets do the same thing.
+        run: |
+          # Record untracked files in the index without staging their contents,
+          # so that classes generated for a newly added transaction or ledger
+          # entry type show up in the diff below rather than silently as an
+          # empty one.
+          git add --intent-to-add .
+          DIFF=$(git status --porcelain)
+          if [ -n "${DIFF}" ]; then
+              # Print the differences to give the contributor a hint about what to
+              # expect when running code generation on their own machine.
+              git diff
+              echo "${MESSAGE}"
+              exit 1
+          fi

.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@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - 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-otel-naming.yml

@@ -0,0 +1,78 @@
+# This workflow checks that OpenTelemetry span-attribute names stay consistent
+# across the code (*SpanNames.h), collector, Tempo, dashboards, and docs.
+# See .github/scripts/otel-naming/check_otel_naming.py and the
+# "Telemetry span attribute naming" section in CONTRIBUTING.md.
+name: Check OTel naming
+
+# This workflow can only be triggered by other workflows.
+on: workflow_call
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-otel-naming
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  otel-naming:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - name: Test the OTel naming checker
+        # The checker's own unit tests, run before the check itself so a broken
+        # rule is reported as a broken rule rather than as a naming violation
+        # (or, worse, as a rule that silently stops flagging anything).
+        # stdlib `unittest` only: the repo installs no third-party test runner
+        # for CI, and the checker itself is deliberately dependency-free.
+        run: python -m unittest discover -s .github/scripts/otel-naming -p 'test_*.py' --verbose
+      - name: Check OTel naming
+        # The script is stdlib-only and reads only files already in the tree;
+        # it enforces each rule only when the layer it needs is present, so it
+        # works whether telemetry changes land in one PR or several.
+        run: python .github/scripts/otel-naming/check_otel_naming.py
+      - name: Check histogram bucket parity
+        # The C++ millisecond ladder and the collector's spanmetrics ladder are
+        # specified to agree over their shared range. They were identical when
+        # first shipped, then the collector side alone was extended and nothing
+        # noticed for eleven phases: native histograms stayed capped at 5s while
+        # spans reached 30s, so every quantile above 5s reported a flat 5000.
+        # Nothing but a check keeps two lists in step.
+        run: python .github/scripts/telemetry/check_bucket_parity.py
+      - name: Test the workload regression-bounds checker
+        # Its own tests, run before the check itself so a broken rule is
+        # reported as a broken rule rather than as a threshold violation. They
+        # also pin the input-handling contract: a placeholder baseline passes
+        # (that is the documented bootstrap state) while a missing, unreadable
+        # or malformed input fails, so deleting an input cannot silence the
+        # check. stdlib unittest only, as with the naming checker.
+        run: python -m unittest discover -s .github/scripts/telemetry -p 'test_*.py' --verbose
+      - name: Check workload regression bounds
+        # The workload gate's absolute bounds are derived from the committed
+        # baseline plus the two ladders, and nothing tied the three together.
+        # That let the gate break three times the same way -- the microsecond
+        # floor moved, the span floor moved, then the bounds stayed calibrated
+        # for a band the spans had left, so a 100x regression reported zero
+        # regressions and exit 0. Every failure looked like a green build.
+        # This asserts each bound is still the one its own baseline implies.
+        run: python .github/scripts/telemetry/check_regression_bounds.py
+      - name: Install the workload harness dependencies
+        # Its own step so a PyPI outage is reported as an install failure rather
+        # than as a failing harness. Last in the job, because every check above
+        # is stdlib-only and stays reachable if this fails.
+        run: pip3 install -r docker/telemetry/workload/requirements.txt
+      - name: Test the telemetry workload harness
+        # Run here rather than in the telemetry validation so a broken harness is
+        # reported in seconds instead of after a full xrpld build, and on every
+        # PR rather than only when that workflow's paths match.
+        #
+        # Plain scripts, not `unittest discover`: these files hold bare test
+        # functions, not TestCase subclasses, so discover would collect nothing
+        # and exit 0. Each file fails when it collects no tests, which is what
+        # makes running them this way safe.
+        run: |
+          python3 docker/telemetry/workload/test_validate_telemetry.py
+          python3 docker/telemetry/workload/test_capture_timings.py
+          python3 docker/telemetry/workload/test_tx_submitter.py

.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@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - 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,200 @@
+name: Run clang-tidy on files
+
+on:
+  workflow_call:
+    inputs:
+      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: /tmp/clang-tidy-output.txt
+  FILTERED_OUTPUT_FILE: /tmp/clang-tidy-filtered-output.txt
+  DIFF_FILE: /tmp/clang-tidy-git-diff.txt
+  ISSUE_FILE: /tmp/clang-tidy-issue.md
+
+  COMPILER: clang
+
+jobs:
+  determine-files:
+    permissions:
+      contents: read
+    uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@70145243b905dc3e040a61d39c00e178cfb96f71
+
+  run-clang-tidy:
+    name: Run clang tidy
+    needs: [determine-files]
+    if: ${{ needs.determine-files.outputs.cpp_changed_files != '' || needs.determine-files.outputs.need_full_run == 'true' }}
+    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
+    container: "ghcr.io/xrplf/xrpld/nix-debian:sha-060957e"
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        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: Set compiler environment
+        uses: ./.github/actions/set-compiler-env
+        with:
+          compiler: ${{ env.COMPILER }}
+
+      - name: Use cargo artifacts cache
+        uses: ./.github/actions/cargo-cache
+        with:
+          cache-directories: ${{ env.BUILD_DIR }}/corrosion
+          workspaces: crates -> ../${{ env.BUILD_DIR }}/cargo
+
+      - 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 \
+              -Dverify_headers=ON \
+              -Drust=ON \
+              ..
+
+      - name: Build clang-tidy prerequisites
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          ninja -j ${{ steps.nproc.outputs.nproc }} tidy_prerequisites
+
+      - name: Run clang tidy
+        id: run_clang_tidy
+        continue-on-error: true
+        env:
+          TARGETS: ${{ needs.determine-files.outputs.need_full_run != 'true' && needs.determine-files.outputs.cpp_changed_files || 'include src tests' }}
+        run: |
+          set -o pipefail
+          run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" -quiet -fix -format -allow-no-checks ${TARGETS} 2>&1 | tee "${OUTPUT_FILE}"
+
+      - name: Print filtered clang-tidy errors
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
+        run: |
+          bin/filter-clang-tidy.py "${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 filtered clang-tidy output to issue body
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
+        run: |
+          if [ -f "${OUTPUT_FILE}" ]; then
+              # Filter to the unique errors with their source context.
+              bin/filter-clang-tidy.py "${OUTPUT_FILE}" >"${FILTERED_OUTPUT_FILE}" || true
+
+              # If filtered output is empty, use original (might be a different error format)
+              if [ ! -s "${FILTERED_OUTPUT_FILE}" ]; then
+                  cp "${OUTPUT_FILE}" "${FILTERED_OUTPUT_FILE}"
+              fi
+
+              # Truncate if too large
+              head -c 60000 "${FILTERED_OUTPUT_FILE}" >>"${ISSUE_FILE}"
+              if [ "$(wc -c <"${FILTERED_OUTPUT_FILE}")" -gt 60000 ]; then
+                  echo "" >>"${ISSUE_FILE}"
+                  echo "... (output truncated, see artifacts for full output)" >>"${ISSUE_FILE}"
+              fi
+
+              rm "${FILTERED_OUTPUT_FILE}"
+          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@2b8bc36af85b88bca0dd7bfac2e2dc05f94ad712
+        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-package-test-install.yml

@@ -0,0 +1,120 @@
+# Install one package format on every distro family it targets, one job per
+# package name and image, and run the binaries there. Called once per format by
+# reusable-package.yml, which owns the names and the image lists.
+name: Install packages
+
+on:
+  workflow_call:
+    inputs:
+      package_type:
+        description: 'The package format to install ("deb" or "rpm").'
+        required: true
+        type: string
+      package_names:
+        description: "JSON array of package names built for this format."
+        required: true
+        type: string
+      images:
+        description: "JSON array of container images to install in."
+        required: true
+        type: string
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  PACKAGE_DIR: packages
+
+jobs:
+  install:
+    strategy:
+      fail-fast: false
+      matrix:
+        package_name: ${{ fromJson(inputs.package_names) }}
+        image: ${{ fromJson(inputs.images) }}
+    name: "${{ matrix.package_name }} on ${{ matrix.image }}"
+    permissions:
+      contents: read
+    runs-on: ubuntu-latest
+    container: ${{ matrix.image }}
+    timeout-minutes: 5
+
+    steps:
+      # Every package lands in one directory; the step below picks its own,
+      # which keeps this independent of the artifact names.
+      - name: Download package artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: "*-pkg"
+          merge-multiple: true
+          path: ${{ env.PACKAGE_DIR }}
+
+      - name: Find the package
+        id: find
+        env:
+          PACKAGE_NAME: ${{ matrix.package_name }}
+          PACKAGE_TYPE: ${{ inputs.package_type }}
+        run: |
+          # The version follows the name, separated by '_' in a DEB and '-' in an
+          # RPM. Requiring a digit after it is what keeps 'xrpld' from picking up
+          # another package, such as 'xrpld-assert'.
+          pattern="${PACKAGE_NAME}[_-][0-9]*.${PACKAGE_TYPE}"
+          package="$(find "${PACKAGE_DIR}" -type f -name "${pattern}" -print -quit)"
+          test -n "${package}" || {
+              echo "no ${pattern} found in ${PACKAGE_DIR}" >&2
+              exit 1
+          }
+          echo "package=${package}" >>"${GITHUB_OUTPUT}"
+
+      # Debian 11 went end-of-life on 2026-08-31
+      # (https://www.debian.org/News/2026/20260831) and its packages are
+      # already partly gone from deb.debian.org, so switch to the
+      # snapshot.debian.org entries the image ships commented out in its
+      # sources.list: they are pinned to the snapshot the image was built
+      # from, so they serve every version it needs and never go away.
+      # Snapshots keep their original, long-passed Valid-Until, hence the
+      # disabled check; the retries absorb snapshot.debian.org's throttling.
+      - name: Switch Debian 11 to snapshot.debian.org
+        if: ${{ matrix.image == 'debian:11' }}
+        run: |
+          sed -i 's|^deb |# deb |; s|^# deb http://snapshot|deb http://snapshot|' /etc/apt/sources.list
+          printf '%s\n' \
+              'Acquire::Check-Valid-Until "false";' \
+              'Acquire::Retries "3";' \
+              >/etc/apt/apt.conf.d/99snapshot
+
+      - name: Install the DEB
+        if: ${{ inputs.package_type == 'deb' }}
+        env:
+          DEBIAN_FRONTEND: noninteractive
+          PACKAGE: ${{ steps.find.outputs.package }}
+        run: |
+          # Stock Debian and Ubuntu images carry no package lists, so apt has
+          # nothing to resolve the systemd dependency from until it fetches them.
+          apt-get update -qq
+          apt-get install -y "./${PACKAGE}"
+
+      - name: Install the RPM
+        if: ${{ inputs.package_type == 'rpm' }}
+        env:
+          PACKAGE: ${{ steps.find.outputs.package }}
+        run: dnf install -y "./${PACKAGE}"
+
+      - name: Run xrpld
+        run: xrpld --version
+
+      - name: Run validator-keys
+        run: validator-keys --version
+
+      - name: Run rippled, the legacy compatibility symlink
+        run: rippled --version
+
+      - name: Check the service account
+        run: id xrpld
+
+      - name: Check the state directory
+        run: test -d /var/lib/xrpld
+
+      - name: Check the log directory
+        run: test -d /var/log/xrpld

.github/workflows/reusable-package.yml

@@ -0,0 +1,244 @@
+# Build, verify and publish Linux packages from the pre-built xrpld and
+# validator-keys artifacts, in three stages:
+#
+#   - 'package' builds and signs one format per config that carries a "package"
+#     map in linux.json; that map names the container image and the format
+#   - 'test-install-deb' and 'test-install-rpm' call
+#     reusable-package-test-install.yml to install what was built on a range of
+#     distros and run the binaries there, so a package that cannot be installed
+#     never reaches Nexus
+#   - 'publish' uploads with the image's publish_pkg.py, doing a --dry-run
+#     unless 'publish: true'
+#
+# Only linux/amd64 is supported; the runner is hardcoded in the jobs below.
+name: Package
+
+on:
+  workflow_call:
+    inputs:
+      publish:
+        description: "Whether to publish the packages after building them."
+        required: false
+        type: boolean
+        default: false
+      nexus_url:
+        description: "The base URL of the Nexus instance hosting the deb and rpm repositories."
+        required: false
+        type: string
+        default: https://packages-upload.xrplf.org
+
+    secrets:
+      remote_username:
+        description: "The username of a Nexus account with write access to the repositories."
+        required: false
+      remote_password:
+        description: "The password or token for that Nexus account."
+        required: false
+      signing_key:
+        description: "Armoured PGP private key used to sign the RPMs. Required when publishing."
+        required: false
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  BUILD_DIR: build
+  PACKAGE_DIR: packages
+
+jobs:
+  generate-matrix:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.generate.outputs.matrix }}
+      deb_package_names: ${{ steps.generate.outputs.deb_package_names }}
+      rpm_package_names: ${{ steps.generate.outputs.rpm_package_names }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.13"
+
+      - name: Generate packaging matrix
+        id: generate
+        working-directory: .github/scripts/strategy-matrix
+        run: ./generate.py --packaging >>"${GITHUB_OUTPUT}"
+
+  package:
+    needs: [generate-matrix]
+    if: ${{ github.event.repository.visibility == 'public' || startsWith(github.ref, 'refs/tags/') }}
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
+    name: "${{ matrix.xrpld_artifact_name }}"
+    permissions:
+      contents: read
+    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
+    container: ${{ matrix.image }}
+    timeout-minutes: 10
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        with:
+          enable_ccache: false
+
+      - name: Download pre-built xrpld binary
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: ${{ matrix.xrpld_artifact_name }}
+          path: ${{ env.BUILD_DIR }}
+
+      - name: Download pre-built validator-keys binary
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: ${{ matrix.validator_keys_artifact_name }}
+          path: ${{ env.BUILD_DIR }}
+
+      - name: Make binaries executable
+        run: chmod +x "${BUILD_DIR}/xrpld" "${BUILD_DIR}/validator-keys"
+
+      - name: Determine release info
+        id: release_info
+        uses: ./.github/actions/release-info
+
+      - name: Build package
+        env:
+          PACKAGE_TYPE: ${{ matrix.package_type }}
+          PACKAGE_VARIANT: ${{ matrix.package_variant }}
+          PKG_RELEASE: ${{ steps.release_info.outputs.pkg_release }}
+          CHANNEL: ${{ steps.release_info.outputs.channel }}
+        run: |
+          ./package/build_pkg.py \
+              --package-type "${PACKAGE_TYPE}" \
+              --build-dir "${BUILD_DIR}" \
+              --pkg-release "${PKG_RELEASE}" \
+              --variant "${PACKAGE_VARIANT}" \
+              --channel "${CHANNEL}"
+
+      # Before the upload, so the artifact, the tested package and the published
+      # package are the same bytes.
+      - name: Sign RPM
+        if: ${{ inputs.publish && matrix.package_type == 'rpm' }}
+        env:
+          PKG_SIGNING_KEY: ${{ secrets.signing_key }}
+        run: ./package/sign_rpm.py --package-dir "${BUILD_DIR}"
+
+      # Split from the debug symbols, which are an order of magnitude larger, so
+      # that test-install downloads only what it installs. In the globs below the
+      # version follows the name, separated by '_' in a DEB and '-' in an RPM. A
+      # version starts with a digit and a longer name does not, so that one digit
+      # is what tells 'xrpld-3.4.1-...' from 'xrpld-assert-3.4.1-...'.
+      - name: Upload package artifact
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: ${{ matrix.xrpld_artifact_name }}-pkg
+          path: |
+            ${{ env.BUILD_DIR }}/debbuild/${{ matrix.package_name }}_[0-9]*.deb
+            ${{ env.BUILD_DIR }}/rpmbuild/RPMS/**/${{ matrix.package_name }}-[0-9]*.rpm
+          if-no-files-found: error
+
+      - name: Upload debug symbol artifact
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: ${{ matrix.xrpld_artifact_name }}-pkg-debug
+          path: |
+            ${{ env.BUILD_DIR }}/debbuild/${{ matrix.package_name }}-dbgsym_[0-9]*.deb
+            ${{ env.BUILD_DIR }}/debbuild/${{ matrix.package_name }}-dbgsym_[0-9]*.ddeb
+            ${{ env.BUILD_DIR }}/rpmbuild/RPMS/**/${{ matrix.package_name }}-debuginfo-[0-9]*.rpm
+          if-no-files-found: error
+
+  # One call per format, so a variant packaged for one format is installed for
+  # that format alone. The images are every distro family that format targets,
+  # oldest release first, so both ends of the dependency range the packages
+  # declare are exercised.
+  test-install-deb:
+    needs: [generate-matrix, package]
+    name: install deb
+    uses: ./.github/workflows/reusable-package-test-install.yml
+    with:
+      package_type: deb
+      package_names: ${{ needs.generate-matrix.outputs.deb_package_names }}
+      images: |
+        [
+          "debian:11",
+          "debian:12",
+          "debian:13",
+          "ubuntu:20.04",
+          "ubuntu:22.04",
+          "ubuntu:24.04",
+          "ubuntu:26.04"
+        ]
+
+  test-install-rpm:
+    needs: [generate-matrix, package]
+    name: install rpm
+    uses: ./.github/workflows/reusable-package-test-install.yml
+    with:
+      package_type: rpm
+      package_names: ${{ needs.generate-matrix.outputs.rpm_package_names }}
+      images: |
+        [
+          "almalinux:9",
+          "almalinux:10",
+          "rockylinux/rockylinux:9",
+          "rockylinux/rockylinux:10",
+          "registry.access.redhat.com/ubi9/ubi",
+          "registry.access.redhat.com/ubi10/ubi"
+        ]
+
+  publish:
+    needs: [generate-matrix, package, test-install-deb, test-install-rpm]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
+    # The name says which of the two this is, because the job runs either way:
+    # with publish false it passes --dry-run and uploads nothing, and a job
+    # called "publish ..." succeeding on a pull request reads like a release.
+    name: "publish ${{ matrix.xrpld_artifact_name }}${{ !inputs.publish && ' (dry run)' || '' }}"
+    permissions:
+      contents: read
+    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
+    container: ${{ matrix.image }}
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        with:
+          enable_ccache: false
+
+      # Both artifacts, so the debug symbols are published alongside the package.
+      - name: Download package artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: ${{ matrix.xrpld_artifact_name }}-pkg*
+          merge-multiple: true
+          path: ${{ env.PACKAGE_DIR }}
+
+      - name: Determine release info
+        id: release_info
+        uses: ./.github/actions/release-info
+
+      - name: Publish package
+        env:
+          CHANNEL: ${{ steps.release_info.outputs.channel }}
+          DRY_RUN_OPTION: ${{ !inputs.publish && '--dry-run' || '' }}
+          NEXUS_URL: ${{ inputs.nexus_url }}
+          NEXUS_USERNAME: ${{ inputs.publish && secrets.remote_username || '' }}
+          NEXUS_PASSWORD: ${{ inputs.publish && secrets.remote_password || '' }}
+        run: |
+          publish_pkg.py \
+              --channel "${CHANNEL}" \
+              --package-dir "${PACKAGE_DIR}" \
+              --nexus-url "${NEXUS_URL}" \
+              ${DRY_RUN_OPTION}

.github/workflows/reusable-rust.yml

@@ -0,0 +1,84 @@
+# Clippy, coverage and documentation for the Rust crates in crates/. Each runs
+# as an independent job on a GitHub-hosted runner, but inside the same container
+# image used to build the crates in the C++/Corrosion path, so the toolchain
+# (and therefore the lints and the cargo cache) matches what production builds
+# use. Coverage is the exception: it needs the nightly rustc that honours
+# #[coverage(off)], which the image carries alongside the pinned stable.
+#
+# Rust unit tests are deliberately NOT run here. They run as part of the C++
+# build (reusable-build-test-config.yml), which already compiles the crates on a
+# self-hosted runner, so there is no need to provision a toolchain again.
+name: Rust
+
+on:
+  workflow_call:
+    secrets:
+      CODECOV_TOKEN:
+        description: "The Codecov token to use for uploading coverage reports."
+        required: true
+
+defaults:
+  run:
+    shell: bash
+    working-directory: crates
+
+permissions:
+  contents: read
+
+jobs:
+  clippy:
+    runs-on: ubuntu-latest
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Use cargo artifacts cache
+        uses: ./.github/actions/cargo-cache
+
+      - name: Run clippy
+        run: cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
+
+  coverage:
+    runs-on: ubuntu-latest
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Use the nightly Rust toolchain
+        run: rust-nightly path >>"${GITHUB_PATH}"
+
+      - name: Use cargo artifacts cache
+        uses: ./.github/actions/cargo-cache
+
+      - name: Generate coverage report
+        run: cargo llvm-cov nextest --workspace --all-features --locked --no-tests=warn --lcov --output-path lcov.info
+
+      - name: Upload coverage report
+        if: ${{ github.repository == 'XRPLF/rippled' }}
+        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
+        with:
+          disable_search: true
+          disable_telem: true
+          fail_ci_if_error: true
+          files: crates/lcov.info
+          flags: rust
+          plugins: noop
+          token: ${{ secrets.CODECOV_TOKEN }}
+          verbose: true
+
+  doc:
+    runs-on: ubuntu-latest
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Use cargo artifacts cache
+        uses: ./.github/actions/cargo-cache
+
+      - name: Build documentation
+        env:
+          RUSTDOCFLAGS: "-D warnings"
+        run: cargo doc --workspace --no-deps --all-features --locked

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

@@ -0,0 +1,42 @@
+name: Generate strategy matrix
+
+on:
+  workflow_call:
+    inputs:
+      os:
+        description: 'The operating system to use for the build ("linux", "macos", "windows", or empty for all).'
+        required: false
+        type: string
+    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@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.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}', inputs.os) || '' }}
+          # Run only the minimal matrix for pull requests that are not yet
+          # labeled "Ready to merge" or "Full CI build". Any other event (merge
+          # queue, push, schedule, manual dispatch) runs the full matrix.
+          GENERATE_MINIMAL: ${{ (github.event_name == 'pull_request' && !contains(github.event.pull_request.labels.*.name, 'Ready to merge') && !contains(github.event.pull_request.labels.*.name, 'Full CI build')) && '--minimal' || '' }}
+        run: ./generate.py ${GENERATE_CONFIG} ${GENERATE_MINIMAL} >>"${GITHUB_OUTPUT}"

.github/workflows/reusable-telemetry-validation.yml

@@ -0,0 +1,446 @@
+# Telemetry Validation CI Workflow
+#
+# Builds rippled, runs the multi-node workload harness, validates all telemetry
+# data, and runs performance benchmarks.
+#
+# The build runs whatever the caller's tree configures, so a telemetry-off tree
+# is compiled here too. Only the validation is gated: a build with the tracing
+# compiled out emits no spans and no metrics to assert on.
+#
+# The caller decides only whether to start this at all. on-pr.yml runs it when
+# telemetry-relevant paths changed.
+#
+# The workflow is intentionally heavyweight (builds rippled, starts Docker
+# services, runs a multi-node cluster) — it validates the full telemetry
+# stack end-to-end rather than individual unit tests.
+#
+# Architecture: three jobs to leverage cached dependencies:
+#   0. linux-image-tag — reads the CI image tag from the build matrix so this
+#      workflow cannot drift onto a different compiler than the main CI.
+#   1. build-xrpld — runs on a self-hosted runner inside the same container
+#      image the main CI uses. This ensures Conan packages are fetched from
+#      the XRPLF remote instead of built from source, and ccache hits the
+#      remote cache. It also reports whether the configured build has telemetry
+#      compiled in.
+#   2. validate-telemetry — runs on ubuntu-latest (which has Docker) to
+#      launch the telemetry stack (OTel collector, Prometheus, Tempo, etc.)
+#      and validate the full pipeline end-to-end, against the binary job 1
+#      uploaded. Skipped when job 1 reports telemetry off.
+
+name: Telemetry Validation
+
+on:
+  workflow_call:
+    inputs:
+      run_benchmark:
+        description: "Run performance benchmarks."
+        required: false
+        type: boolean
+        default: false
+
+concurrency:
+  group: telemetry-validation-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  BUILD_DIR: build
+
+jobs:
+  # ── Job 0: Resolve the CI image tag ────────────────────────────────
+  # The tag is pinned once, alongside the build matrix, in linux.json. Reading
+  # it here rather than hardcoding a second copy means this workflow always
+  # builds in the same image (and therefore the same compiler) as the main CI.
+  # A hardcoded copy silently went stale and left this job on gcc 13 after the
+  # rest of CI moved to gcc 15, which broke the build on code the main CI
+  # compiled fine.
+  linux-image-tag:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Read nix image tag
+        id: tag
+        run: echo "tag=$(jq -r .image_tag .github/scripts/strategy-matrix/linux.json)" >>"${GITHUB_OUTPUT}"
+
+  # ── Job 1: Build xrpld in the same container the main CI uses ──────
+  # This ensures Conan binary packages are fetched from the XRPLF remote
+  # (matching package IDs) and ccache hits the remote compilation cache.
+  build-xrpld:
+    name: Build xrpld
+    needs: linux-image-tag
+    outputs:
+      telemetry: ${{ steps.telemetry.outputs.enabled }}
+    runs-on: [self-hosted, Linux, X64, heavy]
+    container: ghcr.io/xrplf/xrpld/nix-debian:${{ needs.linux-image-tag.outputs.tag }}
+    timeout-minutes: 60
+    env:
+      CCACHE_NAMESPACE: telemetry-validation
+      CCACHE_REMOTE_ONLY: true
+      CCACHE_REMOTE_STORAGE: http://cache.dev.ripplex.io:8080|layout=bazel
+      CCACHE_SLOPPINESS: include_file_ctime,include_file_mtime
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@c00c22ada3bd6bcda48fcb0d62fbbab49fec8a0f
+        with:
+          enable_ccache: ${{ github.repository_owner == 'XRPLF' }}
+
+      - 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: 2
+
+      # The nix image ships several toolchains, so CC/CXX must be set
+      # explicitly for Conan to detect the intended one. gcc matches the
+      # debian gcc-release config the main CI builds.
+      - name: Set compiler environment
+        uses: ./.github/actions/set-compiler-env
+        with:
+          compiler: gcc
+
+      - 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: Release
+          log_verbosity: verbose
+
+      # The telemetry option is deliberately not repeated here. Conan owns it and
+      # the generated toolchain hands its value to CMake. A command-line define
+      # is written to the cache before the toolchain runs and wins over it, so it
+      # could turn telemetry on with the package never fetched.
+      - name: Configure CMake
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          cmake \
+              -G Ninja \
+              -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+              -DCMAKE_BUILD_TYPE=Release \
+              ..
+
+      # A build with tracing compiled out emits nothing to assert on, so the
+      # validation job below gates on this. Read from the configured build, so
+      # this file holds no copy of the setting.
+      #
+      # Every value CMake does not accept as a boolean fails the job, including a
+      # missing entry. A gate that guessed would skip the validation silently,
+      # which is the one failure it must not have.
+      - name: Read whether telemetry is compiled in
+        id: telemetry
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          value=$(sed -n 's/^telemetry:[^=]*=//p' CMakeCache.txt)
+          case "${value}" in
+              True | TRUE | true | ON | on | YES | yes | Y | y | 1) enabled=true ;;
+              False | FALSE | false | OFF | off | NO | no | N | n | 0) enabled=false ;;
+              *)
+                  echo "telemetry reads '${value}' in CMakeCache.txt, which is not" >&2
+                  echo "a boolean. conan install sets it through the toolchain." >&2
+                  exit 1
+                  ;;
+          esac
+          echo "telemetry compiled in: ${enabled}"
+          echo "enabled=${enabled}" >>"${GITHUB_OUTPUT}"
+
+      - name: Build xrpld
+        working-directory: ${{ env.BUILD_DIR }}
+        env:
+          BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
+        run: |
+          cmake \
+              --build . \
+              --config Release \
+              --parallel "${BUILD_NPROC}" \
+              --target xrpld
+
+      - name: Show ccache statistics
+        if: ${{ github.repository_owner == 'XRPLF' }}
+        run: ccache --show-stats -vv
+
+      - name: Upload xrpld binary
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: xrpld-telemetry
+          path: ${{ env.BUILD_DIR }}/xrpld
+          retention-days: 1
+          if-no-files-found: error
+
+  # ── Job 2: Run telemetry validation on ubuntu-latest (has Docker) ──
+  validate-telemetry:
+    name: Telemetry Stack Validation
+    needs: build-xrpld
+    # Reuses the binary job 1 built and uploaded, so a skip here costs no build.
+    if: needs.build-xrpld.outputs.telemetry == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Install Python dependencies
+        run: pip3 install -r docker/telemetry/workload/requirements.txt
+
+      - name: Download xrpld binary
+        uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+        with:
+          name: xrpld-telemetry
+          path: ${{ env.BUILD_DIR }}
+
+      - name: Make binaries and scripts executable
+        run: |
+          chmod +x ${{ env.BUILD_DIR }}/xrpld
+          chmod +x docker/telemetry/workload/*.sh
+
+      - name: Run full telemetry validation
+        id: validation
+        env:
+          RPC_RATE: "50"
+          RPC_DURATION: "120"
+          TX_TPS: "5"
+          TX_DURATION: "120"
+          RUN_BENCHMARK: ${{ inputs.run_benchmark }}
+        run: |
+          # The four rate/duration flags below are inert:
+          # run-full-validation.sh parses them and never reads them. Load shape
+          # comes from the default --profile full-validation. They are still
+          # passed so the flags stay exercised if they are ever wired up.
+          ARGS="--xrpld ${{ env.BUILD_DIR }}/xrpld"
+          ARGS="$ARGS --rpc-rate $RPC_RATE"
+          ARGS="$ARGS --rpc-duration $RPC_DURATION"
+          ARGS="$ARGS --tx-tps $TX_TPS"
+          ARGS="$ARGS --tx-duration $TX_DURATION"
+          if [ "$RUN_BENCHMARK" = "true" ]; then
+              ARGS="$ARGS --with-benchmark"
+          fi
+          docker/telemetry/workload/run-full-validation.sh $ARGS
+        # continue-on-error allows subsequent steps (artifact upload,
+        # summary printing) to run even if validation fails. The final
+        # "Check validation result" step re-checks steps.validation.outcome
+        # (the pre-continue-on-error result) and fails the job properly.
+        continue-on-error: true
+
+      - name: Upload validation reports
+        if: always()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: telemetry-validation-reports
+          path: /tmp/xrpld-validation/reports/
+          retention-days: 30
+
+      # Keyed on the validation step's own outcome, not job status. The step
+      # above sets continue-on-error, so the job is not failing at this point
+      # and `if: failure()` never fires -- which silently skipped these logs on
+      # every failed run, and they are the only record of why a node did not
+      # reach consensus.
+      #
+      # stdout.log matters as much as debug.log: a node that dies before its
+      # log sink opens writes no debug.log at all, so stdout is the only place
+      # its reason survives. A run that timed out at 4/5 nodes was left
+      # undiagnosable because that file was not collected.
+      - name: Upload node logs
+        if: always() && steps.validation.outcome != 'success'
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: xrpld-node-logs
+          path: |
+            /tmp/xrpld-validation/node*/debug.log
+            /tmp/xrpld-validation/node*/stdout.log
+            /tmp/xrpld-validation/*.log
+          retention-days: 7
+          if-no-files-found: warn
+
+      - name: Print validation summary
+        if: always()
+        run: |
+          REPORT="/tmp/xrpld-validation/reports/validation-report.json"
+          if [ -f "$REPORT" ]; then
+              echo "## Telemetry Validation Results" >>"$GITHUB_STEP_SUMMARY"
+              echo "" >>"$GITHUB_STEP_SUMMARY"
+              TOTAL=$(jq '.summary.total' "$REPORT")
+              PASSED=$(jq '.summary.passed' "$REPORT")
+              FAILED=$(jq '.summary.failed' "$REPORT")
+              echo "| Metric | Value |" >>"$GITHUB_STEP_SUMMARY"
+              echo "|--------|-------|" >>"$GITHUB_STEP_SUMMARY"
+              echo "| Total Checks | $TOTAL |" >>"$GITHUB_STEP_SUMMARY"
+              echo "| Passed | $PASSED |" >>"$GITHUB_STEP_SUMMARY"
+              echo "| Failed | $FAILED |" >>"$GITHUB_STEP_SUMMARY"
+              echo "" >>"$GITHUB_STEP_SUMMARY"
+              if [ "$FAILED" -gt 0 ]; then
+                  echo "### Failed Checks" >>"$GITHUB_STEP_SUMMARY"
+                  echo "" >>"$GITHUB_STEP_SUMMARY"
+                  jq -r '.checks[] | select(.passed == false) | "- **\(.name)**: \(.message)"' "$REPORT" >>"$GITHUB_STEP_SUMMARY"
+              fi
+          fi
+
+      # Publishes captured OTel timings + regression report to the Step Summary.
+      # When the committed baseline is a placeholder AND the capture is
+      # complete, emits a fenced JSON block that can be copy-pasted directly
+      # into baselines/baseline-timings.json. An incomplete capture is named as
+      # such and its JSON withheld — see the comment on that branch below.
+      # When the baseline is populated, summarises the top regressions so the
+      # PR author sees the failure reason without downloading artifacts.
+      - name: Print regression summary
+        if: always()
+        run: |
+          set -euo pipefail
+          TIMINGS="/tmp/xrpld-validation/reports/timings.json"
+          REGRESSION="/tmp/xrpld-validation/reports/regression-report.json"
+          BASELINE="docker/telemetry/workload/baselines/baseline-timings.json"
+
+          if [ ! -f "$TIMINGS" ]; then
+              echo "## Regression Gate: no timings captured" >>"$GITHUB_STEP_SUMMARY"
+              echo "::warning::capture_timings.py did not produce timings.json — regression gate was not evaluated."
+              exit 0
+          fi
+
+          if [ ! -f "$BASELINE" ]; then
+              echo "## Regression Gate: baseline file missing" >>"$GITHUB_STEP_SUMMARY"
+              echo "::error::baselines/baseline-timings.json not found in checkout"
+              exit 1
+          fi
+
+          # NOTE: do NOT use `jq -e` here. With -e, jq exits non-zero when the
+          # filter's result is boolean false — which is the normal case for a
+          # populated (non-placeholder) baseline — and that would be
+          # misreported as a parse failure. Plain `jq -r` exits 0 on any valid
+          # JSON, so a real non-zero exit genuinely means malformed JSON.
+          IS_PLACEHOLDER=$(jq -r '.placeholder == true or (.metrics | length == 0)' "$BASELINE") || {
+              echo "::error::Failed to parse baseline JSON"
+              exit 1
+          }
+
+          # Whether the capture is usable as baseline material is the capture's
+          # own verdict, carried in the artifact by capture_timings.py, which
+          # computes it against --min-capture-ratio. It is READ here, never
+          # re-derived: a second copy of the ratio rule in shell would be a
+          # second source of truth and would drift from the producer.
+          #
+          # `// false` covers both an artifact written before the block existed
+          # and a truncated one. Neither can prove it is complete, so neither is
+          # offered — the whole point is that a degraded capture must not look
+          # like a good one. Same `jq -r` reasoning as the baseline parse above.
+          CAPTURE_COMPLETE=$(jq -r '.capture.complete // false' "$TIMINGS") || {
+              echo "::error::Failed to parse timings JSON"
+              exit 1
+          }
+          if [ "$(jq -r 'has("capture")' "$TIMINGS")" = "true" ]; then
+              CAPTURE_COUNTS=$(jq -r '"\(.capture.captured)/\(.capture.declared)"' "$TIMINGS")
+              CAPTURE_SHORTFALL="only **$CAPTURE_COUNTS** declared metrics came back, below the capture's own minimum ratio"
+          else
+              CAPTURE_COUNTS="unknown"
+              CAPTURE_SHORTFALL="the artifact carries no \`capture\` block, so it predates completeness reporting and cannot state what it captured"
+          fi
+
+          echo "## OTel Timings Regression Gate" >>"$GITHUB_STEP_SUMMARY"
+          echo "" >>"$GITHUB_STEP_SUMMARY"
+
+          if [ "$IS_PLACEHOLDER" = "true" ] && [ "$CAPTURE_COMPLETE" != "true" ]; then
+              # The placeholder path is the ONLY route to a committed baseline,
+              # which makes it the one place an incomplete capture does lasting
+              # damage: pasted in, it silently narrows the gate to the keys that
+              # happened to come back. So the JSON is withheld rather than
+              # printed with a caveat — a warning above a copyable block is
+              # still a copyable block. The counts are shown so the reader knows
+              # how thin it was, and the artifact is still uploaded for anyone
+              # who needs to inspect it deliberately.
+              echo "### Baseline NOT refreshable from this run" >>"$GITHUB_STEP_SUMMARY"
+              echo "" >>"$GITHUB_STEP_SUMMARY"
+              echo "The committed baseline is a placeholder, so this run would" \
+                  "normally print a block to paste into" \
+                  "\`baselines/baseline-timings.json\`. It is withheld because" \
+                  "$CAPTURE_SHORTFALL, so the JSON may describe metrics that" \
+                  "were never measured. Pasting it would narrow the gate to" \
+                  "whichever keys were captured, with nothing reporting that" \
+                  "it had narrowed." >>"$GITHUB_STEP_SUMMARY"
+              echo "" >>"$GITHUB_STEP_SUMMARY"
+              echo "Fix the capture first — the usual cause is Prometheus not" \
+                  "being scraped for long enough, or nodes not reaching" \
+                  "consensus — then re-run. See the \`timings.json\` artifact's" \
+                  "\`capture\` block for the exact counts." >>"$GITHUB_STEP_SUMMARY"
+              echo "::error::Timing capture is incomplete ($CAPTURE_COUNTS metrics) — no baseline block printed. Do not refresh the baseline from this run."
+          elif [ "$IS_PLACEHOLDER" = "true" ]; then
+              echo "### Paste into \`baselines/baseline-timings.json\`" >>"$GITHUB_STEP_SUMMARY"
+              echo "" >>"$GITHUB_STEP_SUMMARY"
+              echo "The committed baseline is a placeholder. Open a PR replacing" \
+                  "its contents with the JSON block below to activate the" \
+                  "regression gate. The capture is complete" \
+                  "($CAPTURE_COUNTS declared metrics)." >>"$GITHUB_STEP_SUMMARY"
+              echo "" >>"$GITHUB_STEP_SUMMARY"
+              echo '```json' >>"$GITHUB_STEP_SUMMARY"
+              cat "$TIMINGS" >>"$GITHUB_STEP_SUMMARY"
+              echo '```' >>"$GITHUB_STEP_SUMMARY"
+          elif [ -f "$REGRESSION" ]; then
+              # Existence is not readability: a truncated report satisfies -f,
+              # and the `|| =0` fallbacks below would then render a clean table
+              # of zeros for a run that compared nothing. Same trap the note
+              # above the baseline parse warns about, so check the shape first.
+              SUMMARY_OK=$(jq -r 'if (.summary | type) == "object" then "yes" else "no" end' \
+                  "$REGRESSION" 2>/dev/null) || SUMMARY_OK=no
+              if [ "$SUMMARY_OK" != "yes" ]; then
+                  echo "## Regression Gate: report unreadable" >>"$GITHUB_STEP_SUMMARY"
+                  echo "" >>"$GITHUB_STEP_SUMMARY"
+                  echo "\`$REGRESSION\` exists but carries no \`summary\` object, so no" \
+                      "table can be rendered. The pass/fail above still comes from the" \
+                      "comparator's exit code." >>"$GITHUB_STEP_SUMMARY"
+                  echo "::error::Regression report is present but has no summary object"
+              else
+                  # No `jq -e`: it exits non-zero when a field is legitimately 0 or
+                  # false, which the fallbacks would silently turn into 0 as well.
+                  REGR_COUNT=$(jq -r '.summary.regressions // 0' "$REGRESSION")
+                  IMPR_COUNT=$(jq -r '.summary.improvements // 0' "$REGRESSION")
+                  TOTAL=$(jq -r '.summary.total // 0' "$REGRESSION")
+                  MISSING_COUNT=$(jq -r '.summary.missing_in_current // 0' "$REGRESSION")
+                  COMPARED=$(jq -r '.summary.compared // 0' "$REGRESSION")
+                  # `total` is every key in the report, i.e. the union of the
+                  # baseline and this run, so it is not what was gated. The
+                  # comparator reports `compared` for that; do not derive it from
+                  # total minus missing, because a key can also be skipped for
+                  # being new or for having no data on either side.
+                  echo "| Stat | Count |" >>"$GITHUB_STEP_SUMMARY"
+                  echo "|------|-------|" >>"$GITHUB_STEP_SUMMARY"
+                  echo "| Metrics in report | $TOTAL |" >>"$GITHUB_STEP_SUMMARY"
+                  echo "| Metrics compared | $COMPARED |" >>"$GITHUB_STEP_SUMMARY"
+                  echo "| Not captured this run | $MISSING_COUNT |" >>"$GITHUB_STEP_SUMMARY"
+                  echo "| Regressions | $REGR_COUNT |" >>"$GITHUB_STEP_SUMMARY"
+                  echo "| Improvements | $IMPR_COUNT |" >>"$GITHUB_STEP_SUMMARY"
+                  echo "" >>"$GITHUB_STEP_SUMMARY"
+                  if [ "$MISSING_COUNT" -gt 0 ]; then
+                      echo "::warning::$MISSING_COUNT baseline metric(s) were not captured this run, so they were not gated"
+                  fi
+                  if [ "$REGR_COUNT" -gt 0 ]; then
+                      echo "### Regressions" >>"$GITHUB_STEP_SUMMARY"
+                      echo "" >>"$GITHUB_STEP_SUMMARY"
+                      echo "| Metric | Baseline | Current | Δ | % | Unit |" >>"$GITHUB_STEP_SUMMARY"
+                      echo "|--------|---------:|--------:|--:|--:|------|" >>"$GITHUB_STEP_SUMMARY"
+                      jq -r '.metrics[] | select(.regressed) | "| \(.key) | \(.baseline) | \(.current) | \(.delta) | \(.pct_change)% | \(.unit) |"' \
+                          "$REGRESSION" >>"$GITHUB_STEP_SUMMARY"
+                  fi
+              fi
+          fi
+
+      - name: Cleanup
+        if: always()
+        run: |
+          docker/telemetry/workload/run-full-validation.sh --cleanup 2>/dev/null || true
+
+      - name: Check validation result
+        if: steps.validation.outcome == 'failure'
+        run: |
+          echo "Telemetry validation failed. Check the uploaded reports for details."
+          exit 1

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

@@ -0,0 +1,100 @@
+# 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.xrplf.org/repository/conan/
+
+    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/xrpld/nix-ubuntu:sha-060957e
+    env:
+      REMOTE_NAME: ${{ inputs.remote_name }}
+      CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.remote_username }}
+      CONAN_PASSWORD_XRPLF: ${{ secrets.remote_password }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        with:
+          enable_ccache: false
+
+      - name: Determine release info
+        id: release_info
+        uses: ./.github/actions/release-info
+
+      - 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
+        run: conan remote login "${REMOTE_NAME}" "${CONAN_LOGIN_USERNAME_XRPLF}" --password "${CONAN_PASSWORD_XRPLF}"
+
+      - name: Upload Conan recipe (version)
+        run: |
+          conan export . --version=${{ steps.release_info.outputs.version }}
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/${{ steps.release_info.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' }}
+        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' }}
+        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/') }}
+        run: |
+          conan export . --version=release
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/release
+
+    outputs:
+      ref: xrpl/${{ steps.release_info.outputs.version }}

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

@@ -0,0 +1,130 @@
+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
+      - conan/profiles/**
+
+env:
+  CONAN_REMOTE_NAME: xrplf
+  CONAN_REMOTE_URL: https://conan.xrplf.org/repository/conan/
+  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
+
+  # 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) }}
+    runs-on: ${{ matrix.architecture.runner }}
+    container: ${{ matrix.image || 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@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        with:
+          enable_ccache: false
+
+      # Before any step that uses a build tool, composite actions included.
+      - name: Setup Nix environment
+        if: ${{ matrix.toolchain == 'nix' }}
+        uses: ./.github/actions/setup-nix-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: ${{ env.NPROC_SUBTRACT }}
+
+      - name: Set compiler environment (Linux)
+        if: ${{ runner.os == 'Linux' }}
+        uses: ./.github/actions/set-compiler-env
+        with:
+          compiler: ${{ matrix.compiler }}
+
+      # `setup-nix-env` already did this for the Nix toolchain.
+      - name: Setup Conan
+        if: ${{ matrix.toolchain != 'nix' }}
+        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: Check the Conan cache for Nix store references (Nix toolchain)
+        if: ${{ matrix.toolchain == 'nix' }}
+        run: ./bin/check-nix-store-refs.sh "${CONAN_HOME}"
+
+      - 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.NEXUS_REMOTE_USERNAME }}" --password "${{ secrets.NEXUS_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' || '' }}
+          CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.NEXUS_REMOTE_USERNAME }}
+          CONAN_PASSWORD_XRPLF: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+        run: conan upload "*" --remote="${CONAN_REMOTE_NAME}" --confirm ${FORCE_OPTION}

.github/workflows/windows.yml

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

.gitignore

@@ -1,70 +1,52 @@
 # .gitignore
+# cspell: disable
 
-bin/boostbook_catalog.xml
-bin/config.log
-bin/project-cache.jam
-
-# 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
-.nih_c
-tags
-TAGS
-GTAGS
-GRTAGS
-GPATH
-bin/rippled
-Debug/*.*
-Release/*.*
+*.pdb
+*.swp
+/.clangd
+Debug/
+Release/
+/.build/
+/.venv/
+/build/
+/db/
+/out.txt
+/Testing/
+/tmp/
+CMakeSettings.json
+CMakeUserPresets.json
 
-# Ignore coverage files.
+# Coverage files.
 *.gcno
 *.gcda
 *.gcov
 
-# Levelization checking
-Builds/levelization/results/rawincludes.txt
-Builds/levelization/results/paths.txt
-Builds/levelization/results/includes/
-Builds/levelization/results/includedby/
+# Profiling data.
+gmon.out
 
-# Ignore tmp directory.
-tmp
+# Levelization data.
+.github/scripts/levelization/results/*
+!.github/scripts/levelization/results/loops.txt
+!.github/scripts/levelization/results/ordering.txt
 
-# Ignore database directory.
-db/
-db/*.db
-db/*.db-*
+# Customized configs.
+/rippled.cfg
+/xrpld.cfg
+/validators.txt
 
-# Ignore debug logs
-debug_log.txt
+# Locally patched Conan recipes
+external/conan-center-index/
 
-# Ignore customized configs
-rippled.cfg
-validators.txt
+# Local conan directory
+.conan
 
-# Doxygen generated documentation output
-HtmlDocumentation
-docs/html_doc
-
-# Xcode user-specific project settings
-# Xcode
-.DS_Store
-/build/
+# XCode IDE.
 *.pbxuser
 !default.pbxuser
 *.mode1v3
@@ -77,38 +59,44 @@ 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.
+# Shared/committable AI agent config (AGENTS.md, CLAUDE.md, GEMINI.md, .claude/settings.json,
+# tool-specific rules files, etc.) should be checked in — see CONTRIBUTING.md. Only the
+# personal/local variants below are ignored.
+/.agent
+/.agents
+/.augment
+/.claude/settings.local.json
+AGENTS.override.md
+CLAUDE.local.md
+GEMINI.local.md
 
-Builds/VisualStudio2015/*.db
-Builds/VisualStudio2015/*.user
-Builds/VisualStudio2015/*.opendb
-Builds/VisualStudio2015/*.sdf
+# Python
+__pycache__
 
-# MSVC
-*.pdb
-.vs/
-CMakeSettings.json
-compile_commands.json
-.clangd
-packages
-pkg_out
-pkg
-CMakeUserPresets.json
-bld.rippled/
-.vscode
+# Rust build artifacts.
+target/
 
-# Suggested in-tree build directory
-/.build/
+# Direnv's directory
+/.direnv
+
+# clangd cache
+/.cache
+
+# Rust build directory
+crates/target
+
+# Env. file carrying environmental setup data for local or cloud runs.
+.env.*

.pre-commit-config.yaml

@@ -1,6 +1,176 @@
-# .pre-commit-config.yaml
+# 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/mirrors-clang-format
-  rev: v18.1.3
-  hooks:
-  - id: clang-format
+  - 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: check-executables-have-shebangs
+      - 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]
+        # .ipp fragments are included by their owning header rather than compiled
+        # as standalone translation units, so they have no compile_commands.json
+        # entry to lint (verify_headers checks them transitively).
+        exclude: '^include/xrpl/protocol_autogen|\.ipp$'
+        # run-clang-tidy --fix may edit headers included by files it is not run on,
+        # so pre-commit must not split the files across parallel hook invocations.
+        # The script determines the staged files itself and lets run-clang-tidy
+        # handle parallelism internally.
+        pass_filenames: false
+      - 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)/
+      - id: fix-pragma-once
+        name: fix missing '#pragma once' declarations in header files
+        language: python
+        entry: ./bin/pre-commit/fix_pragma_once.py
+        files: \.(h|hpp)$
+      - id: check-doxygen-style
+        name: check Doxygen comment style
+        entry: ./bin/pre-commit/check_doxygen_style.py
+        language: python
+        types_or: [c++, c]
+      - id: fix-gtest-names
+        name: "fix gtest names: CamelCase suite, snake_case test case"
+        entry: ./bin/pre-commit/fix_gtest_names.py
+        language: python
+        types_or: [c++, c]
+
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: f4d7745e17a28aad7eed2f4874ca8d1568c11c4c # frozen: v22.1.8
+    hooks:
+      - id: clang-format
+        args: [--style=file]
+        types_or: [c++, c, proto]
+        exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_entries)/
+
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --manifest-path crates/Cargo.toml --all
+        language: system
+        types: [rust]
+        pass_filenames: false # rustfmt formats the whole workspace
+      - id: check-coverage-attrs
+        name: check Rust coverage attributes
+        entry: ./bin/pre-commit/check_rust_coverage_attrs.py
+        language: python
+        files: ^crates/.*\.rs$
+
+  - repo: https://github.com/BlankSpruce/gersemi-pre-commit
+    rev: e98930bdc210d3387007f9252d8c1694ea7e410f # frozen: 0.27.7
+    hooks:
+      - id: gersemi
+
+  - repo: https://github.com/rbubley/mirrors-prettier
+    rev: 9337a74165b178ae2c766f60bee7252a0f06f3e8 # frozen: v3.9.5
+    hooks:
+      - id: prettier
+        args: [--end-of-line=auto]
+
+  # Scoped to package/: the rest of the repo's Python has pre-existing findings,
+  # so widening these is its own change.
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: 7c55798a78262d14b2074abf623d8a992ebb70d4 # frozen: v0.16.2
+    hooks:
+      - id: ruff-check
+        args: [--fix]
+        files: ^package/.*\.py$
+
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 4160603246a6b365d4a2af661c6d71b0a0f50478 # frozen: 26.5.1
+    hooks:
+      - id: black
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: 41e691678310dfd3833f7ab4e180ddb014310356 # frozen: v2.3.0
+    hooks:
+      - id: mypy
+        args: [--strict]
+        files: ^package/.*\.py$
+
+  - repo: https://github.com/scop/pre-commit-shfmt
+    rev: 05c1426671b9237fb5e1444dd63aa5731bec0dfb # frozen: v3.13.1-1
+    hooks:
+      - id: shfmt
+        args: [--write, --indent=4, --case-indent=true]
+
+  - repo: local
+    hooks:
+      - id: format-inline-bash-workflows
+        name: "format `run:` blocks in workflows/actions"
+        entry: ./.github/scripts/format-inline-bash.py
+        language: python
+        files: ^\.github/(workflows|actions)/.*\.ya?ml$
+      - id: format-inline-bash-markdown
+        name: "format ```bash blocks in markdown"
+        entry: ./.github/scripts/format-inline-bash.py
+        language: python
+        files: \.md$
+
+  - repo: https://github.com/streetsidesoftware/cspell-cli
+    rev: ea11f9efc0bec520073405bc30552da887ba71bc # frozen: v10.0.1
+    hooks:
+      - id: cspell
+        name: check changed files spelling
+        exclude: |
+          (?x)^(
+              \.cspell\.config\.yaml|
+              include/xrpl/protocol_autogen/(transactions|ledger_entries)/.*
+          )$
+      - id: cspell
+        name: check commit message spelling
+        args:
+          - --no-must-find-files
+          - --no-progress
+          - --no-summary
+        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

AGENTS.md

@@ -0,0 +1,42 @@
+# AGENTS.md
+
+This file provides guidance to AI coding agents (Claude Code, and other AGENTS.md-compatible tools) when working with code in this repository.
+
+## Build
+
+Required on Linux/macOS: use the Nix devshell, which sets up the compiler, Conan, ccache, and (optionally) Rust automatically.
+
+```bash
+nix develop
+```
+
+For alternate devshell variants (specific compiler, no-compiler, coverage), see [docs/build/nix.md](./docs/build/nix.md). For the manual build steps, CMake options, and protocol codegen commands, see [BUILD.md](./BUILD.md) (`## Steps`, `## Options`, `## Code generation`).
+
+Rust crate tests (independent of the CMake build): `cargo test --manifest-path crates/Cargo.toml --workspace` (CI uses `cargo nextest`).
+
+## Testing
+
+Unit tests are a custom framework built into the `xrpld` binary itself (not Boost.Test/GTest/Catch); see [CONTRIBUTING.md](./CONTRIBUTING.md#unit-tests) for the basic invocation. Notes not covered there:
+
+- A suite's `--unittest` name is built from the arguments to its `BEAST_DEFINE_TESTSUITE`/`BEAST_DEFINE_TESTSUITE_PRIO` macro (usually at the bottom of the test file), in reverse order and joined with `.`: `BEAST_DEFINE_TESTSUITE(Credentials, app, xrpl)` → `xrpl.app.Credentials`.
+- `--unittest-arg` does nothing — don't use it.
+- Tests that run offline in under a minute should be automatic `--unittest` suites; anything else is a manual/integration test.
+- New tests should be written using `gtest` under `src/tests/` unless that isn't possible, in which case fall back to the legacy Beast framework under `src/test/`. `tests/` (top-level) holds integration tests exercised against `libxrpl`/`xrpld`.
+
+## Lint/Format
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md#pre-commit-hooks) for `pre-commit` setup and [CONTRIBUTING.md](./CONTRIBUTING.md#clang-tidy) for `clang-tidy` (opt-in, needs local `clang-tidy` and generated headers).
+
+## Code Style
+
+New file placement and header levelization: see [CONTRIBUTING.md](./CONTRIBUTING.md#before-making-a-pull-request). Braces, whitespace, member order, and other conventions: see [docs/CodingStyle.md](./docs/CodingStyle.md). `XRPL_ASSERT`/`UNREACHABLE` contracts: see [CONTRIBUTING.md](./CONTRIBUTING.md#contracts-and-instrumentation). Commit messages: see [CONTRIBUTING.md](./CONTRIBUTING.md#good-commit-messages).
+
+## Architecture
+
+Paths below reflect the current layout; update this section if modularization moves a subsystem to a different directory.
+
+- `include/xrpl/` + `src/libxrpl/` — the core protocol library: ledger, shamap, consensus, crypto, json, resource, nodestore, rdb, peerfinder, and `tx/` (transaction application: `Transactor.cpp`, `applySteps.cpp`, invariants, payment paths). `tx/transactors/` has one file per transaction type, grouped by subsystem: `escrow/`, `vault/`, `lending/`, `sponsor/`, `nft/`, `token/` (MPT), `payment_channel/`, `permissioned_domain/`, `dex/`, `oracle/`, `did/`, `credentials/`, `bridge/`, `check/`, `delegate/`, `account/`, `system/`. Any change to transaction-processing behavior must be gated behind an Amendment.
+- `src/xrpld/` — the server application built on top of `libxrpl`: `app`, `core`, `overlay` (P2P networking), `peerfinder`, `perflog`, `rpc`, `shamap`. `main` builds an `ApplicationImp` implementing `Application`; most components hold a reference to it (`app_`), giving broad cross-component access — expect to trace call chains through `Application&`.
+- `src/test/` — unit tests mirroring the subsystems above, plus `jtx/` (the transaction-building test DSL — e.g. `jtx/escrow.h`, `jtx/vault.h`, `jtx/sponsor.h`, `jtx/permissioned_dex.h`) and `unit_test/` (the custom test framework itself, derived from Beast).
+- `src/tests/` — unit tests for `libxrpl` written in `gtest`, gradually replacing the `src/test` equivalents.
+- `crates/` — a Rust workspace (only built with `-Dxrpld -Drust=ON`) bridged into C++ via `cxxbridge`/the `cxx` crate; currently just a `hello_world` interop scaffold. Requires the Rust toolchain pinned in `rust-toolchain.toml` (the Nix devshell provides it automatically).

API-CHANGELOG.md

@@ -4,92 +4,168 @@ This changelog is intended to list all updates to the [public API methods](https
 
 For info about how [API versioning](https://xrpl.org/request-formatting.html#api-versioning) works, including examples, please view the [XLS-22d spec](https://github.com/XRPLF/XRPL-Standards/discussions/54). For details about the implementation of API versioning, view the [implementation PR](https://github.com/XRPLF/rippled/pull/3155). API versioning ensures existing integrations and users continue to receive existing behavior, while those that request a higher API version will experience new behavior.
 
-The API version controls the API behavior you see. This includes what properties you see in responses, what parameters you're permitted to send in requests, and so on. You specify the API version in each of your requests. When a breaking change is introduced to the `rippled` API, a new version is released. To avoid breaking your code, you should set (or increase) your version when you're ready to upgrade.
-
-For a log of breaking changes, see the **API Version [number]** headings. In general, breaking changes are associated with a particular API Version number. For non-breaking changes, scroll to the **XRP Ledger version [x.y.z]** headings. Non-breaking changes are associated with a particular XRP Ledger (`rippled`) release.
-
-## API Version 2
-
-API version 2 is available in `rippled` version 2.0.0 and later. To use this API, clients specify `"api_version" : 2` in each request.
-
-#### Removed methods
-
-In API version 2, the following deprecated methods are no longer available: (https://github.com/XRPLF/rippled/pull/4759)
-
-- `tx_history` - Instead, use other methods such as `account_tx` or `ledger` with the `transactions` field set to `true`.
-- `ledger_header` - Instead, use the `ledger` method.
-
-#### Modifications to JSON transaction element in V2
-
-In API version 2, JSON elements for transaction output have been changed and made consistent for all methods which output transactions. (https://github.com/XRPLF/rippled/pull/4775)
-This helps to unify the JSON serialization format of transactions. (https://github.com/XRPLF/clio/issues/722, https://github.com/XRPLF/rippled/issues/4727)
-
-- JSON transaction element is named `tx_json`
-- Binary transaction element is named `tx_blob`
-- JSON transaction metadata element is named `meta`
-- Binary transaction metadata element is named `meta_blob`
-
-Additionally, these elements are now consistently available next to `tx_json` (i.e. sibling elements), where possible:
-
-- `hash` - Transaction ID. This data was stored inside transaction output in API version 1, but in API version 2 is a sibling element.
-- `ledger_index` - Ledger index (only set on validated ledgers)
-- `ledger_hash` - Ledger hash (only set on closed or validated ledgers)
-- `close_time_iso` - Ledger close time expressed in ISO 8601 time format (only set on validated ledgers)
-- `validated` - Bool element set to `true` if the transaction is in a validated ledger, otherwise `false`
-
-This change affects the following methods:
-
-- `tx` - Transaction data moved into element `tx_json` (was inline inside `result`) or, if binary output was requested, moved from `tx` to `tx_blob`. Renamed binary transaction metadata element (if it was requested) from `meta` to `meta_blob`. Changed location of `hash` and added new elements
-- `account_tx` - Renamed transaction element from `tx` to `tx_json`. Renamed binary transaction metadata element (if it was requested) from `meta` to `meta_blob`. Changed location of `hash` and added new elements
-- `transaction_entry` - Renamed transaction metadata element from `metadata` to `meta`. Changed location of `hash` and added new elements
-- `subscribe` - Renamed transaction element from `transaction` to `tx_json`. Changed location of `hash` and added new elements
-- `sign`, `sign_for`, `submit` and `submit_multisigned` - Changed location of `hash` element.
-
-#### Modification to `Payment` transaction JSON schema
-
-When reading Payments, the `Amount` field should generally **not** be used. Instead, use [delivered_amount](https://xrpl.org/partial-payments.html#the-delivered_amount-field) to see the amount that the Payment delivered. To clarify its meaning, the `Amount` field is being renamed to `DeliverMax`. (https://github.com/XRPLF/rippled/pull/4733)
-
-- In `Payment` transaction type, JSON RPC field `Amount` is renamed to `DeliverMax`. To enable smooth client transition, `Amount` is still handled, as described below: (https://github.com/XRPLF/rippled/pull/4733)
-  - On JSON RPC input (e.g. `submit_multisigned` etc. methods), `Amount` is recognized as an alias to `DeliverMax` for both API version 1 and version 2 clients.
-  - On JSON RPC input, submitting both `Amount` and `DeliverMax` fields is allowed _only_ if they are identical; otherwise such input is rejected with `rpcINVALID_PARAMS` error.
-  - On JSON RPC output (e.g. `subscribe`, `account_tx` etc. methods), `DeliverMax` is present in both API version 1 and version 2.
-  - On JSON RPC output, `Amount` is only present in API version 1 and _not_ in version 2.
-
-#### Modifications to account_info response
-
-- `signer_lists` is returned in the root of the response. (In API version 1, it was nested under `account_data`.) (https://github.com/XRPLF/rippled/pull/3770)
-- When using an invalid `signer_lists` value, the API now returns an "invalidParams" error. (https://github.com/XRPLF/rippled/pull/4585)
-  - (`signer_lists` must be a boolean. In API version 1, strings were accepted and may return a normal response - i.e. as if `signer_lists` were `true`.)
-
-#### Modifications to [account_tx](https://xrpl.org/account_tx.html#account_tx) response
-
-- Using `ledger_index_min`, `ledger_index_max`, and `ledger_index` returns `invalidParams` because if you use `ledger_index_min` or `ledger_index_max`, then it does not make sense to also specify `ledger_index`. In API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4571)
-  - The same applies for `ledger_index_min`, `ledger_index_max`, and `ledger_hash`. (https://github.com/XRPLF/rippled/issues/4545#issuecomment-1565065579)
-- Using a `ledger_index_min` or `ledger_index_max` beyond the range of ledgers that the server has:
-  - returns `lgrIdxMalformed` in API version 2. Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/issues/4288)
-- Attempting to use a non-boolean value (such as a string) for the `binary` or `forward` parameters returns `invalidParams` (`rpcINVALID_PARAMS`). Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4620)
-
-#### Modifications to [noripple_check](https://xrpl.org/noripple_check.html#noripple_check) response
-
-- Attempting to use a non-boolean value (such as a string) for the `transactions` parameter returns `invalidParams` (`rpcINVALID_PARAMS`). Previously, in API version 1, no error was returned. (https://github.com/XRPLF/rippled/pull/4620)
-
-## API Version 1
-
-This version is supported by all `rippled` versions. For WebSocket and HTTP JSON-RPC requests, it is currently the default API version used when no `api_version` is specified.
+The 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.
 
-### Inconsistency: server_info - network_id
+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.
 
-The `network_id` field was added in the `server_info` response in version 1.5.0 (2019), but it is not returned in [reporting mode](https://xrpl.org/rippled-server-modes.html#reporting-mode). However, use of reporting mode is now discouraged, in favor of using [Clio](https://github.com/XRPLF/clio) instead.
+## 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.
+
+## XRP Ledger server version 3.4.0
+
+Version 3.4.0 is not yet released. These changes are available in the 3.4.0 beta releases.
+
+### Additions in 3.4.0
+
+- `ledger`: `nftoken_id`, `nftoken_ids`, and `offer_id` are now included in transaction metadata when transactions are expanded (`expand`, or admin-only `full`), matching the `tx`, `account_tx`, and `subscribe` (`transactions` stream) responses. ([#5706](https://github.com/XRPLF/rippled/pull/5706))
+
+### Bugfixes in 3.4.0
+
+- `sign`, `sign_for`, `submit`: `signature_target` now returns `invalidParams` unless it names `CounterpartySignature` or `SponsorSignature`. It previously accepted any inner object field, such as `Book` or `NFToken`, and signed into it.
+- `sign`, `sign_for`, `submit`, `submit_multisigned`: With `fixCleanup3_4_0` enabled, a signature in `CounterpartySignature` or `SponsorSignature` covers a different prefix than the transaction's own signature, so a signature can no longer be moved from one of those roles into another. Clients that build these signatures themselves must use the new prefixes: `CPT` and `CPM` (single- and multi-signing) for `CounterpartySignature`, and `SPN` and `SPM` for `SponsorSignature`.
+- `get_aggregate_price`: Duplicate entries in the `oracles` request array are now ignored. [#6586](https://github.com/XRPLF/rippled/pull/6586)
+- `vault_info`: Errors now identify what the request got wrong instead of reporting every failure as the unregistered token `malformedRequest`, and the `error`, `error_code` and `error_message` fields now agree with each other. An invalid `vault_id` or `seq` returns `invalidParams`, an invalid `owner` returns `actMalformed`, and a request that mixes `vault_id` with `owner`/`seq` or supplies neither returns `invalidParams` with a message naming the accepted combinations. [#8015](https://github.com/XRPLF/rippled/pull/8015)
+- `vault_info`: A well-formed all-zero `vault_id` now returns `entryNotFound` instead of being rejected as malformed, and `entryNotFound` responses now include `error_code` and `error_message`. Clients that request `ripplerpc` 3.0 or above therefore receive HTTP 400 with that error rather than HTTP 200. [#8015](https://github.com/XRPLF/rippled/pull/8015)
+- `vault_info`: `vault_id` and `owner` must now be strings, matching how `ledger_entry` reads the same fields. An object or an array in either field previously produced an internal error, and a number was silently converted to its decimal text; `vault_id` now returns `invalidParams` and `owner` returns `actMalformed`. [#8015](https://github.com/XRPLF/rippled/pull/8015)
+- `gateway_balances`: The `account` and `ident` fields now return an `invalidParams` error if the value is not a string, instead of an `internal` error. [#7655](https://github.com/XRPLF/rippled/pull/7655)
+- `account_lines`: The `peer` field now returns an error if the value is not a string. [#7728](https://github.com/XRPLF/rippled/pull/7728)
+- `ledger`: `delivered_amount` is now included in the metadata of successful `AccountDelete` transactions when transactions are expanded (`expand`, or admin-only `full`). Previously it was only added for `Payment` and `CheckCash`, which made `ledger` inconsistent with `tx` and `account_tx`. [#5706](https://github.com/XRPLF/rippled/pull/5706)
+- `noripple_check`: The `transactions` field is no longer included in error responses; it is still returned (possibly as an empty array) whenever `transactions` is `true` and the request succeeds. A malformed `account` is now rejected before the ledger is looked up, so that error response no longer carries the `ledger_hash`, `ledger_index`, and `validated` fields ([#6303](https://github.com/XRPLF/rippled/pull/6303)).
+
+## XRP Ledger server version 3.3.0
+
+[Version 3.3.0](https://github.com/XRPLF/rippled/releases/tag/3.3.0) was released on Aug 6, 2026.
+
+### Additions in 3.3.0
+
+- `account_tx`: Added an optional `delegate` request object to filter delegated transactions. The object requires `delegate_filter`, which must be either `actor` for transactions owned by the requested account but signed by another account, or `authorizer` for transactions signed by the requested account on behalf of another account. The optional `counter_party` account narrows the results to a specific signer/delegate for `actor` or a specific owner/delegator for `authorizer`. Malformed `delegate`, `delegate_filter`, and `counter_party` values return standard invalid field errors, and invalid account IDs return `actMalformed`. When paginating delegate-filtered queries, a marker from a delegate-filtered query includes a `delegate` flag and is only valid for follow-up requests that also supply `delegate` (mixing marker conventions returns `invalidParams`). Because filtering is applied after the ledger scan, a page may contain fewer results than `limit` (possibly zero) while still returning a marker, so callers must continue until no marker is present. ([#6126](https://github.com/XRPLF/rippled/pull/6126))
+
+## XRP Ledger server version 3.2.1
+
+[Version 3.2.1](https://github.com/XRPLF/rippled/releases/tag/3.2.1) was released on Aug 1, 2026.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 3.2.0
+
+[Version 3.2.0](https://github.com/XRPLF/rippled/releases/tag/3.2.0) was released on Jun 16, 2026.
+
+### Additions in 3.2.0
+
+- `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 in 3.2.0
+
+- 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.3
+
+[Version 3.1.3](https://github.com/XRPLF/rippled/releases/tag/3.1.3) was released on May 8, 2026.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 3.1.2
+
+[Version 3.1.2](https://github.com/XRPLF/rippled/releases/tag/3.1.2) was released on Mar 12, 2026.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 3.1.1
+
+[Version 3.1.1](https://github.com/XRPLF/rippled/releases/tag/3.1.1) was released on Feb 23, 2026.
+
+This release contains bug fixes only and no API changes.
+
+## 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
 
-As of 2025-04-04, version 2.5.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
+[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
 
-- `channel_authorize`: If `signing_support` is not enabled in the config, the RPC is disabled.
+- `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
 
@@ -97,11 +173,19 @@ As of 2025-04-04, version 2.5.0 is in development. You can use a pre-release ver
 
 ### Additions and bugfixes in 2.4.0
 
-- `ledger_entry`: `state` is added an alias for `ripple_state`.
-- `ledger_entry`: Enables case-insensitive filtering by canonical name in addition to case-sensitive filtering by RPC name.
-- `validators`: Added new field `validator_list_threshold` in response.
-- `simulate`: A new RPC that executes a [dry run of a transaction submission](https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0069d-simulate#2-rpc-simulate)
-- Signing methods autofill fees better and properly handle transactions that don't have a base fee, and will also autofill the `NetworkID` field.
+- `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
 
@@ -109,19 +193,30 @@ As of 2025-04-04, version 2.5.0 is in development. You can use a pre-release ver
 
 ### 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.
+- `book_changes`: If the requested ledger version is not available on this node, a `ledgerNotFound` error is returned and the node does not attempt to acquire the ledger from the p2p network (as with other non-admin RPCs). Admins can still attempt to retrieve old ledgers with the `ledger_request` RPC.
 
 ### Additions and bugfixes in 2.3.0
 
-- `book_changes`: Returns a `validated` field in its response, which was missing in prior versions.
+- `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):
 
-- The `feature` method now has a non-admin mode for users. (It was previously only available to admin connections.) The method returns an updated list of amendments, including their names and other information. ([#4781](https://github.com/XRPLF/rippled/pull/4781))
+- `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
 
@@ -129,24 +224,18 @@ Admins can still attempt to retrieve old ledgers with the `ledger_request` RPC.
 
 - `server_definitions`: A new RPC that generates a `definitions.json`-like output that can be used in XRPL libraries.
 - In `Payment` transactions, `DeliverMax` has been added. This is a replacement for the `Amount` field, which should not be used. Typically, the `delivered_amount` (in transaction metadata) should be used. To ease the transition, `DeliverMax` is present regardless of API version, since adding a field is non-breaking.
-- API version 2 has been moved from beta to supported, meaning that it is generally available (regardless of the `beta_rpc_api` setting).
-
-## XRP Ledger server version 2.2.0
-
-The following is a non-breaking addition to the API.
-
-- The `feature` method now has a non-admin mode for users. (It was previously only available to admin connections.) The method returns an updated list of amendments, including their names and other information. ([#4781](https://github.com/XRPLF/rippled/pull/4781))
+- 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).
+[Version 1.12.0](https://github.com/XRPLF/rippled/releases/tag/1.12.0) was released on Sep 6, 2023. The following additions are non-breaking (because they are purely additive):
 
-- `server_info`: Added `ports`, an array which advertises the RPC and WebSocket ports. This information is also included in the `/crawl` endpoint (which calls `server_info` internally). `grpc` and `peer` ports are also included. (https://github.com/XRPLF/rippled/pull/4427)
+- `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`). (https://github.com/XRPLF/rippled/pull/4553)
-  - Adds an [AccountRoot flag](https://xrpl.org/accountroot.html#accountroot-flags) called `lsfAllowTrustLineClawback` (https://github.com/XRPLF/rippled/pull/4617)
+- 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:
@@ -181,16 +270,16 @@ The following is a non-breaking addition to the API.
 
 ### Breaking changes in 1.11
 
-- Added the ability to mark amendments as obsolete. For the `feature` admin API, there is a new possible value for the `vetoed` field. (https://github.com/XRPLF/rippled/pull/4291)
+- 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. (https://github.com/XRPLF/rippled/pull/4404)
+- 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. (https://github.com/XRPLF/rippled/pull/4398)
+- 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`. (https://github.com/XRPLF/rippled/pull/4370)
+  - 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:
@@ -200,10 +289,10 @@ The following is a non-breaking addition to the API.
 
 ### Additions and bug fixes in 1.11
 
-- Added `nftoken_id`, `nftoken_ids` and `offer_id` meta fields into NFT `tx` and `account_tx` responses. (https://github.com/XRPLF/rippled/pull/4447)
-- Added an `account_flags` object to the `account_info` method response. (https://github.com/XRPLF/rippled/pull/4459)
-- Added `NFTokenPages` to the `account_objects` RPC. (https://github.com/XRPLF/rippled/pull/4352)
-- Fixed: `marker` returned from the `account_lines` command would not work on subsequent commands. (https://github.com/XRPLF/rippled/pull/4361)
+- 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
 

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

@@ -1,208 +1,100 @@
-| :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). |
+| :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).<br><br>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][conan-getting-started] walkthrough. |
 
-> 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.
+## Minimum Requirements
 
-## Branches
+For the hardware needed to run a node, see
+[System Requirements](https://xrpl.org/system-requirements.html).
 
-For a stable release, choose the `master` branch or one of the [tagged
-releases](https://github.com/ripple/rippled/releases).
+For the software needed to build xrpld, see the
+[environment setup guide](./docs/build/environment.md).
 
-```
-git checkout master
-```
+## Operating Systems
 
-For the latest release candidate, choose the `release` branch.
+### Linux
 
-```
-git checkout release
-```
+The Ubuntu Linux distribution has received the highest level of quality
+assurance, testing, and support. We also support Red Hat and use Debian
+internally.
+Our Linux CI tooling is distro-independent and uses a Nix-based environment, so it should be possible to build on other Linux distributions as well, although we have not tested them.
+
+### macOS
+
+Many `xrpld` engineers use macOS for development.
+The minimum supported version is macOS 15 (Sequoia).
+CI testing is done in macOS 26 (Tahoe), but the build defaults `CMAKE_OSX_DEPLOYMENT_TARGET` to 15.
+
+### Windows
+
+Windows is used by some engineers for development only, and is not recommended
+for production use.
+
+## Steps
+
+### Branches
 
 For the latest set of untested features, or to contribute, choose the `develop`
 branch.
 
-```
+```bash
 git checkout develop
 ```
 
-## Minimum Requirements
+For a release candidate, choose the relevant release branch, e.g.
+`release/3.2.x`.
 
-See [System Requirements](https://xrpl.org/system-requirements.html).
+```bash
+git checkout release/3.2.x
+```
 
-Building rippled generally requires git, Python, Conan, CMake, and a C++ compiler. Some guidance on setting up such a [C++ development environment can be found here](./docs/build/environment.md).
-
-- [Python 3.7](https://www.python.org/downloads/)
-- [Conan 1.60](https://conan.io/downloads.html)[^1]
-- [CMake 3.16](https://cmake.org/download/)
-
-[^1]: It is possible to build with Conan 2.x,
-but the instructions are significantly different,
-which is why we are not recommending it yet.
-Notably, the `conan profile update` command is removed in 2.x.
-Profiles must be edited by hand.
-
-`rippled` is written in the C++20 dialect and includes the `<concepts>` header.
-The [minimum compiler versions][2] required are:
-
-| Compiler    | Version |
-|-------------|---------|
-| GCC         | 11      |
-| Clang       | 13      |
-| Apple Clang | 13.1.6  |
-| MSVC        | 19.23   |
-
-### Linux
-
-The Ubuntu operating system has received the highest level of
-quality assurance, testing, and support.
-
-Here are [sample instructions for setting up a C++ development environment on Linux](./docs/build/environment.md#linux).
-
-### Mac
-
-Many rippled engineers use macOS for development.
-
-Here are [sample instructions for setting up a C++ development environment on macOS](./docs/build/environment.md#macos).
-
-### Windows
-
-Windows is not recommended for production use at this time.
-
-- Additionally, 32-bit Windows development is not supported.
-
-[Boost]: https://www.boost.org/
-
-## Steps
+For a stable release, choose one of the [tagged
+releases](https://github.com/XRPLF/rippled/releases).
 
 ### 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.
+Once your [development environment](./docs/build/environment.md) is ready, set
+Conan up for this repository:
 
-These instructions assume a basic familiarity with Conan and CMake.
-
-If you are unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official [Getting Started][3] walkthrough.
-
-You'll need at least one Conan profile:
-
-   ```
-   conan profile new default --detect
-   ```
-
-Update the compiler settings:
-
-   ```
-   conan profile update settings.compiler.cppstd=20 default
-   ```
-
-Configure Conan (1.x only) to use recipe revisions:
-
-   ```
-   conan config set general.revisions_enabled=1
-   ```
-
-**Linux** developers will commonly have a default Conan [profile][] that compiles
-with GCC and links with libstdc++.
-If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
-then you will need to choose the `libstdc++11` ABI:
-
-   ```
-   conan profile update settings.compiler.libcxx=libstdc++11 default
-   ```
-
-
-Ensure inter-operability between `boost::string_view` and `std::string_view` types:
-
-```
-conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_BEAST_USE_STD_STRING_VIEW"]' default
-conan profile update 'env.CXXFLAGS="-DBOOST_BEAST_USE_STD_STRING_VIEW"' default
+```bash
+./conan/init.sh
 ```
 
-If you have other flags in the `conf.tools.build` or `env.CXXFLAGS` sections, make sure to retain the existing flags and append the new ones. You can check them with:
+That installs our [`global.conf`](./conan/global.conf), our Conan
+[profiles](./conan/profiles), and the `xrplf` remote that hosts some of our
+dependencies. It honours `CONAN_HOME` and never deletes an existing Conan home,
+so it is safe to re-run — it only overwrites the files it manages.
+
+> [!TIP]
+> In the [Nix development shell](./docs/build/nix.md#conan-configuration) this is
+> already done for you: the script runs on entry.
+
+You can inspect the resulting profile with `conan profile show`. If it is not
+suitable for your environment, create a custom profile and pass it to Conan — see
+[Advanced Conan configuration](./docs/build/advanced_conan.md).
+
+### 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.
+
+On Linux and macOS, `ccache` is included in the [Nix development shell](./docs/build/nix.md).
+
+#### 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:
+
 ```
-conan profile show default
+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.
 ```
 
-
-**Windows** developers may need to use the x64 native build tools.
-An easy way to do that is to run the shortcut "x64 Native Tools Command
-Prompt" for the version of Visual Studio that you have installed.
-
-   Windows developers must also build `rippled` and its dependencies for the x64
-   architecture:
-
-   ```
-   conan profile update settings.arch=x86_64 default
-   ```
-
-### Multiple compilers
-
-When `/usr/bin/g++` exists on a platform, it is the default cpp compiler. This
-default works for some users.
-
-However, if this compiler cannot build rippled or its dependencies, then you can
-install another compiler and set Conan and CMake to use it.
-Update the `conf.tools.build:compiler_executables` setting in order to set the correct variables (`CMAKE_<LANG>_COMPILER`) in the
-generated CMake toolchain file.
-For example, on Ubuntu 20, you may have gcc at `/usr/bin/gcc` and g++ at `/usr/bin/g++`; if that is the case, you can select those compilers with:
-```
-conan profile update 'conf.tools.build:compiler_executables={"c": "/usr/bin/gcc", "cpp": "/usr/bin/g++"}' default
-```
-
-Replace `/usr/bin/gcc` and `/usr/bin/g++` with paths to the desired compilers.
-
-It should choose the compiler for dependencies as well,
-but not all of them have a Conan recipe that respects this setting (yet).
-For the rest, you can set these environment variables.
-Replace `<path>` with paths to the desired compilers:
-
-- `conan profile update env.CC=<path> default`
-- `conan profile update env.CXX=<path> default`
-
-Export our [Conan recipe for Snappy](./external/snappy).
-It does not explicitly link the C++ standard library,
-which allows you to statically link it with GCC, if you want.
-
-   ```
-   # Conan 1.x
-   conan export external/snappy snappy/1.1.10@
-   # Conan 2.x
-   conan export --version 1.1.10 external/snappy
-   ```
-
-Export our [Conan recipe for RocksDB](./external/rocksdb).
-It does not override paths to dependencies when building with Visual Studio.
-
-   ```
-   # Conan 1.x
-   conan export external/rocksdb rocksdb/9.7.3@
-   # Conan 2.x
-   conan export --version 9.7.3 external/rocksdb
-   ```
-
-Export our [Conan recipe for SOCI](./external/soci).
-It patches their CMake to correctly import its dependencies.
-
-   ```
-   # Conan 1.x
-   conan export external/soci soci/4.0.3@
-   # Conan 2.x
-   conan export --version 4.0.3 external/soci
-   ```
-
-Export our [Conan recipe for NuDB](./external/nudb).
-It fixes some source files to add missing `#include`s.
-
-
-   ```
-   # Conan 1.x
-   conan export external/nudb nudb/2.0.8@
-   # Conan 2.x
-   conan export --version 2.0.8 external/nudb
-   ```
+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
 
@@ -224,98 +116,115 @@ It fixes some source files to add missing `#include`s.
 
 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
-    ```
+   ```
+   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`
+   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.
+   For a single-configuration generator, e.g. `Unix Makefiles` or `Ninja`,
+   you only need to run this command once.
+   For a multi-configuration generator, e.g. `Visual Studio`, you may want to
+   run it more than once.
 
-    Each of these commands should also have a different `build_type` setting.
-    A second command with the same `build_type` setting will overwrite the files
-    generated by the first. You can pass the build type on the command line with
-    `--settings build_type=$BUILD_TYPE` or in the profile itself,
-    under the section `[settings]` with the key `build_type`.
-
-    If you are using a Microsoft Visual C++ compiler,
-    then you will need to ensure consistency between the `build_type` setting
-    and the `compiler.runtime` setting.
-
-    When `build_type` is `Release`, `compiler.runtime` should be `MT`.
-
-    When `build_type` is `Debug`, `compiler.runtime` should be `MTd`.
-
-    ```
-    conan install .. --output-folder . --build missing --settings build_type=Release --settings compiler.runtime=MT
-    conan install .. --output-folder . --build missing --settings build_type=Debug --settings compiler.runtime=MTd
-    ```
+   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:
+   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.
+   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"
+   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 ..
-    ```
+   ```
+   cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release -Dxrpld=ON -Dtests=ON ..
+   ```
 
+   Multi-config generators:
 
-    Multi-config generators:
+   ```
+   cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -Dxrpld=ON -Dtests=ON  ..
+   ```
 
-    ```
-    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.
 
-    **Note:** You can pass build options for `rippled` in this step.
-
-5. Build `rippled`.
+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. 
+   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 . -j $(nproc)
+   cmake --build . --parallel N
    ```
 
    Multi-config generators:
 
    ```
-   cmake --build . --config Release
-   cmake --build . --config Debug
+   cmake --build . --config Release --parallel N
+   cmake --build . --config Debug --parallel N
    ```
 
-6. Test rippled.
+   Replace the `--parallel` parameter N with the desired number of parallel jobs. A common starting point is half of the number of available CPU
+   cores.
+
+5. Test xrpld.
 
    Single-config generators:
 
    ```
-   ./rippled --unittest
+   ./xrpld --unittest --unittest-jobs N
    ```
 
    Multi-config generators:
 
    ```
-   ./Release/rippled --unittest
-   ./Debug/rippled --unittest
+   ./Release/xrpld --unittest --unittest-jobs N
+   ./Debug/xrpld --unittest --unittest-jobs N
    ```
 
-   The location of `rippled` in your build directory depends on your CMake
-   generator. Pass `--help` to see the rest of the command line options.
+   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 same targets are also available as a standalone project, which does not
+need the dependencies to be configured first:
+
+```
+cmake -S cmake/codegen -B build/codegen
+cmake --build build/codegen --target setup_code_gen
+cmake --build build/codegen --target code_gen
+```
+
+The regenerated files should be committed alongside your changes. CI verifies
+that they are up-to-date.
 
 ## Coverage report
 
@@ -327,26 +236,30 @@ which is only enabled when the `coverage` option is set, e.g. with
 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)
+- `gcov` for GCC or `llvm-cov` for Clang, usually installed with the compiler
 - `Debug` build type
 
+> [!NOTE]
+> Clang coverage is not available in the [Nix development shell](./docs/build/nix.md#building-xrpld-in-the-nix-shell):
+> its `clang` shells do not ship `llvm-cov`. Use a `gcc` shell instead (`.#gcc`,
+> or `.#gcc-plain` on Linux), which provides a `gcov` matching its compiler.
+
 A coverage report is created when the following steps are completed, in order:
 
-1. `rippled` binary built with instrumentation data, enabled by the `coverage`
+1. `xrpld` binary built with instrumentation data, enabled by the `coverage`
    option mentioned above
-2. completed run of unit tests, which populates coverage capture data
+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 above steps are automated into a single target `coverage`. The instrumented
-`rippled` binary can also be used for regular development or testing work, at
+The 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). In case of a spurious failure of unit tests, it is
-possible to re-run the `coverage` target without rebuilding the `rippled` binary
-(since it is simply a dependency of the coverage report target). It is also possible
-to select only specific tests for the purpose of the coverage report, by setting
-the `coverage_test` variable in `cmake`
+(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`
@@ -355,11 +268,6 @@ to generate more than one format at a time by setting the `coverage_extra_args`
 variable in `cmake`. The specific command line used to run the `gcovr` tool will be
 displayed if the `CODE_COVERAGE_VERBOSE` variable is set.
 
-By default, the code coverage tool runs parallel unit tests with `--unittest-jobs`
- set to the number of available CPU cores. This may cause spurious test
-errors on Apple. Developers can override the number of unit test jobs with
-the `coverage_test_parallelism` variable in `cmake`.
-
 Example use with some cmake variables set:
 
 ```
@@ -372,48 +280,128 @@ 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
+- 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. |
-| `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
-| `tests` | OFF | Build tests. |
-| `unity` | ON | Configure a unity build. |
-| `xrpld` | OFF | Build the xrpld (`rippled`) application, and not just the libxrpl library. |
+| Option           | Default Value | Description                                                                   |
+| ---------------- | ------------- | ----------------------------------------------------------------------------- |
+| `assert`         | OFF           | Force enabling assertions.                                                    |
+| `coverage`       | OFF           | Prepare the coverage report.                                                  |
+| `rust`           | OFF           | Build the Rust crates and the C++ code that depends on them.                  |
+| `tests`          | OFF           | Build tests.                                                                  |
+| `unity`          | OFF           | Configure a unity build.                                                      |
+| `verify_headers` | ON            | Make the `verify-headers` target available to compile each header on its own. |
+| `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.
+[Unity builds][unity-build] 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.
 
+### Rust crates
+
+The Rust crates in `crates/` are only part of the build when `rust` is ON. With
+`-Drust=OFF` (the default) the `crates` directory is not added to the build, no
+cxxbridge bindings are generated, and the C++ tests that exercise the Rust
+interop are not compiled — so no Rust toolchain is needed. CI builds always pass
+`-Drust=ON`.
+
+With `-Drust=ON` you need one extra dependency: a Rust toolchain (`cargo`,
+`rustc`) matching the channel pinned in
+[`rust-toolchain.toml`](./rust-toolchain.toml), which compiles the crates and
+generates the cxxbridge bindings. It is provided by the
+[Nix development shell](./docs/build/nix.md), so `-Drust=ON` works there without
+any extra setup; otherwise install it as described in
+[Rust](./docs/build/environment.md#rust).
+
+The crates also have their own Rust unit tests. Those are run with `cargo` and
+need only the Rust toolchain, independently of CMake and of the `rust` option
+(CI runs them with `cargo nextest`):
+
+```bash
+cargo test --manifest-path crates/Cargo.toml --workspace
+```
+
+### Verifying headers
+
+The regular build only compiles `.cpp` files, so a header is only ever checked
+through whatever translation unit happens to include it. A header that forgets
+an `#include` is not caught as long as every `.cpp` that uses it includes its
+missing dependency first. The `verify_headers` option (ON by default) adds a
+`verify-headers` target that compiles every header on its own, which fails if a
+header is not self-contained:
+
+```bash
+cmake --build . --target verify-headers
+```
+
+The per-header objects are excluded from the `all` target, so a normal build
+never compiles them; they are built only through `verify-headers`. The generated
+translation units do appear in `compile_commands.json`, so clang-tidy (and
+clangd and IDEs) can lint each header on its own. Pass `-Dverify_headers=OFF` to
+omit them entirely.
 
 ## Troubleshooting
 
-
 ### Conan
 
 After any updates or changes to dependencies, you may need to do the following:
 
 1. Remove your build directory.
-2. Remove the Conan cache:
+2. Remove individual libraries from the Conan cache, e.g.
+
+   ```bash
+   conan remove 'grpc/*'
    ```
-   rm -rf ~/.conan/data
+
+   **or**
+
+   Remove all libraries from Conan cache:
+
+   ```bash
+   conan remove '*'
    ```
-4. Re-run [conan install](#build-and-test).
 
+3. Re-run [conan export](./docs/build/advanced_conan.md#patched-recipes) if needed.
+4. [Regenerate lockfile](./docs/build/advanced_conan.md#conan-lockfile).
+5. Re-run [conan install](#build-and-test).
 
-### 'protobuf/port_def.inc' file not found
+If you are using the Nix development shell, whether prebuilt Conan binaries apply
+depends on your platform — see
+[Prebuilt packages](./docs/build/nix.md#prebuilt-packages).
 
-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.
+#### 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 [set Conan up](#set-up-conan) so the `xrplf` remote is configured, or re-run `conan export` for [patched recipes](./docs/build/advanced_conan.md#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.
 
 ```
-/rippled/.build/pb-xrpl.libpb/xrpl/proto/ripple.pb.h:10:10: fatal error: 'google/protobuf/port_def.inc' file not found
+/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.
@@ -424,77 +412,8 @@ For example, if you want to build Debug:
 1. For conan install, pass `--settings build_type=Debug`
 2. For cmake, pass `-DCMAKE_BUILD_TYPE=Debug`
 
-
-### no std::result_of
-
-If your compiler version is recent enough to have removed `std::result_of` as
-part of C++20, e.g. Apple Clang 15.0, then you might need to add a preprocessor
-definition to your build.
-
-```
-conan profile update 'options.boost:extra_b2_flags="define=BOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
-conan profile update 'env.CFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
-conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
-conan profile update 'conf.tools.build:cflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
-conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
-```
-
-
-### call to 'async_teardown' is ambiguous
-
-If you are compiling with an early version of Clang 16, then you might hit
-a [regression][6] when compiling C++20 that manifests as an [error in a Boost
-header][7]. You can workaround it by adding this preprocessor definition:
-
-```
-conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
-conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
-```
-
-
-### recompile with -fPIC
-
-If you get a linker error suggesting that you recompile Boost with
-position-independent code, such as:
-
-```
-/usr/bin/ld.gold: error: /home/username/.conan/data/boost/1.77.0/_/_/package/.../lib/libboost_container.a(alloc_lib.o):
-  requires unsupported dynamic reloc 11; recompile with -fPIC
-```
-
-Conan most likely downloaded a bad binary distribution of the dependency.
-This seems to be a [bug][1] in Conan just for Boost 1.77.0 compiled with GCC
-for Linux. The solution is to build the dependency locally by passing
-`--build boost` when calling `conan install`.
-
-```
-conan install --build boost ...
-```
-
-
-## Add a Dependency
-
-If you want to experiment with a new package, follow these steps:
-
-1. Search for the package on [Conan Center](https://conan.io/center/).
-2. Modify [`conanfile.py`](./conanfile.py):
-    - Add a version of the package to the `requires` property.
-    - Change any default options for the package by adding them to the
-    `default_options` property (with syntax `'$package:$option': $value`).
-3. Modify [`CMakeLists.txt`](./CMakeLists.txt):
-    - Add a call to `find_package($package REQUIRED)`.
-    - Link a library from the package to the target `ripple_libs`
-    (search for the existing call to `target_link_libraries(ripple_libs INTERFACE ...)`).
-4. Start coding! Don't forget to include whatever headers you need from the package.
-
-
-[1]: https://github.com/conan-io/conan-center-index/issues/13168
-[2]: https://en.cppreference.com/w/cpp/compiler_support/20
-[3]: https://docs.conan.io/en/latest/getting_started.html
-[5]: https://en.wikipedia.org/wiki/Unity_build
-[6]: https://github.com/boostorg/beast/issues/2648
-[7]: https://github.com/boostorg/beast/issues/2661
+[conan-getting-started]: https://docs.conan.io/en/latest/getting_started.html
+[unity-build]: https://en.wikipedia.org/wiki/Unity_build
 [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/levelization/README.md

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

Builds/levelization/levelization.sh

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

Builds/levelization/results/loops.txt

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

Builds/levelization/results/ordering.txt

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

CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

CMakeLists.txt

@@ -1,146 +1,201 @@
 cmake_minimum_required(VERSION 3.16)
 
 if(POLICY CMP0074)
-  cmake_policy(SET CMP0074 NEW)
+    cmake_policy(SET CMP0074 NEW)
 endif()
 if(POLICY CMP0077)
-  cmake_policy(SET CMP0077 NEW)
+    cmake_policy(SET CMP0077 NEW)
 endif()
 
 # Fix "unrecognized escape" issues when passing CMAKE_MODULE_PATH on Windows.
-file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
+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")
 
+# Must be set before project() because project() consumes it when configuring the compiler and SDK.
+# A user-provided -DCMAKE_OSX_DEPLOYMENT_TARGET still takes precedence.
+#
+# CMAKE_SYSTEM_NAME can't be used before project(), so CMAKE_HOST_SYSTEM_NAME is used instead.
+#
+# When CMAKE_OSX_DEPLOYMENT_TARGET is bumped to >=26.0, FastFloat dependency won't be needed anymore
+if(
+    CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin"
+    AND NOT DEFINED CMAKE_OSX_DEPLOYMENT_TARGET
+)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET
+        "15.0"
+        CACHE STRING
+        "Minimum macOS deployment version"
+    )
+endif()
+
 project(xrpl)
 set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+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(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+elseif(is_clang)
     # Clang-specific fixes
     add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
-elseif(MSVC)
+elseif(is_msvc)
     # MSVC-specific fixes
     add_compile_options(/wd4068) # Ignore unknown pragmas
 endif()
 
-# make GIT_COMMIT_HASH define available to all sources
-find_package(Git)
-if(Git_FOUND)
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse HEAD
-        OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
-    if(gch)
-        set(GIT_COMMIT_HASH "${gch}")
-        message(STATUS gch: ${GIT_COMMIT_HASH})
-        add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
-    endif()
-
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse --abbrev-ref HEAD
-        OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
-    if(gb)
-        set(GIT_BRANCH "${gb}")
-        message(STATUS gb: ${GIT_BRANCH})
-        add_definitions(-DGIT_BRANCH="${GIT_BRANCH}")
-    endif()
-endif() #git
+# Enable ccache to speed up builds.
+include(Ccache)
 
 if(thread_safety_analysis)
-  add_compile_options(-Wthread-safety -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS -DRIPPLE_ENABLE_THREAD_SAFETY_ANNOTATIONS)
-  add_compile_options("-stdlib=libc++")
-  add_link_options("-stdlib=libc++")
+    add_compile_options(
+        -Wthread-safety
+        -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+        -DXRPL_ENABLE_THREAD_SAFETY_ANNOTATIONS
+    )
+    add_compile_options("-stdlib=libc++")
+    add_link_options("-stdlib=libc++")
 endif()
 
-include (CheckCXXCompilerFlag)
-include (FetchContent)
-include (ExternalProject)
-include (CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
-if (target)
-  message (FATAL_ERROR "The target option has been removed - use native cmake options to control build")
-endif ()
+include(CheckCXXCompilerFlag)
+include(FetchContent)
+include(ExternalProject)
+include(CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
+if(target)
+    message(
+        FATAL_ERROR
+        "The target option has been removed - use native cmake options to control build"
+    )
+endif()
 
-include(RippledSanity)
-include(RippledVersion)
-include(RippledSettings)
-# this check has to remain in the top-level cmake
-# because of the early return statement
-if (packages_only)
-  if (NOT TARGET rpm)
-    message (FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?")
-  endif()
-  return ()
-endif ()
-include(RippledCompiler)
-include(RippledInterface)
+include(PatchNixBinary)
+
+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(RippledDocs)
+include(XrplDocs)
 if(only_docs)
-  return()
+    return()
 endif()
 
-###
-
 include(deps/Boost)
-find_package(OpenSSL 1.1.1 REQUIRED)
-set_target_properties(OpenSSL::SSL PROPERTIES
-  INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
-)
-set(SECP256K1_INSTALL TRUE)
-add_subdirectory(external/secp256k1)
-add_library(secp256k1::secp256k1 ALIAS secp256k1)
-add_subdirectory(external/ed25519-donna)
+
 add_subdirectory(external/antithesis-sdk)
+find_package(date REQUIRED)
+find_package(ed25519 REQUIRED)
+find_package(FastFloat REQUIRED)
 find_package(gRPC REQUIRED)
-find_package(lz4 REQUIRED)
-# Target names with :: are not allowed in a generator expression.
-# We need to pull the include directories and imported location properties
-# from separate targets.
 find_package(LibArchive REQUIRED)
+find_package(lz4 REQUIRED)
+find_package(mpt-crypto 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)
+
+target_link_libraries(
+    xrpl_libs
+    INTERFACE
+        ed25519::ed25519
+        FastFloat::fast_float
+        lz4::lz4
+        mpt-crypto::mpt-crypto
+        OpenSSL::Crypto
+        OpenSSL::SSL
+        secp256k1::secp256k1
+        soci::soci
+        SQLite::SQLite3
+)
 
 option(rocksdb "Enable RocksDB" ON)
 if(rocksdb)
-  find_package(RocksDB REQUIRED)
-  set_target_properties(RocksDB::rocksdb PROPERTIES
-    INTERFACE_COMPILE_DEFINITIONS RIPPLE_ROCKSDB_AVAILABLE=1
-  )
-  target_link_libraries(ripple_libs INTERFACE RocksDB::rocksdb)
+    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()
 
-find_package(nudb REQUIRED)
-find_package(date REQUIRED)
-find_package(xxHash REQUIRED)
-
-target_link_libraries(ripple_libs INTERFACE
-  ed25519::ed25519
-  lz4::lz4
-  OpenSSL::Crypto
-  OpenSSL::SSL
-  secp256k1::secp256k1
-  soci::soci
-  SQLite::SQLite3
-)
+# OpenTelemetry distributed tracing (optional).
+# When on, links against opentelemetry-cpp and defines XRPL_ENABLE_TELEMETRY so
+# that SpanGuard factory methods produce real OTel spans.
+# When off, all tracing code compiles to no-ops with zero overhead and
+# opentelemetry-cpp is not needed at all.
+#
+# There is no CMake option. The one switch is `conan install -o telemetry=`,
+# which decides whether opentelemetry-cpp is fetched and sets the variable read
+# below through the generated toolchain.
+#
+# -DXRPL_ENABLE_TELEMETRY=OFF turns nothing off: that name is only a compile
+# definition added below, so CMake lists it as an unused variable at the end of
+# configuration.
+if(telemetry)
+    find_package(opentelemetry-cpp CONFIG REQUIRED)
+    add_compile_definitions(XRPL_ENABLE_TELEMETRY)
+    message(STATUS "OpenTelemetry tracing enabled")
+endif()
 
 # Work around changes to Conan recipe for now.
 if(TARGET nudb::core)
-  set(nudb nudb::core)
+    set(nudb nudb::core)
 elseif(TARGET NuDB::nudb)
-  set(nudb NuDB::nudb)
+    set(nudb NuDB::nudb)
 else()
-  message(FATAL_ERROR "unknown nudb target")
+    message(FATAL_ERROR "unknown nudb target")
+endif()
+target_link_libraries(xrpl_libs INTERFACE ${nudb})
+
+if(benchmark)
+    find_package(benchmark REQUIRED)
 endif()
-target_link_libraries(ripple_libs INTERFACE ${nudb})
 
 if(coverage)
-  include(RippledCov)
+    include(XrplCov)
 endif()
 
-set(PROJECT_EXPORT_SET RippleExports)
-include(RippledCore)
-include(RippledInstall)
-include(RippledValidatorKeys)
+add_custom_target(tidy_prerequisites)
+
+if(rust)
+    add_subdirectory(crates)
+endif()
+include(XrplCore)
+
+include(XrplProtocolAutogen)
+include(XrplInstall)
+include(XrplValidatorKeys)
+# Must come after XrplValidatorKeys: the 'package' target depends on the
+# validator-keys target existing.
+include(XrplPackaging)
+
+if(tests)
+    include(CTest)
+    add_subdirectory(src/tests/libxrpl)
+endif()
+
+if(benchmark)
+    add_subdirectory(src/benchmarks/libxrpl)
+endif()

CODEOWNERS

@@ -0,0 +1,4 @@
+# By default, anyone can review changes.
+
+# The CI tooling team should review changes to the CI configuration.
+/.github/ @XRPLF/ci-tooling

LICENSE.md

@@ -1,7 +1,7 @@
-ISC License 
+ISC License
 
 Copyright (c) 2011, Arthur Britto, David Schwartz, Jed McCaleb, Vinnie Falco, Bob Way, Eric Lombrozo, Nikolaos D. Bougalis, Howard Hinnant.
-Copyright (c) 2012-2020, the XRP Ledger developers.
+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
@@ -14,4 +14,3 @@ 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.
-