minor changes

Signed-off-by: Pratik Mankawde <3397372+pratikmankawde@users.noreply.github.com>

.clang-format

@@ -37,7 +37,7 @@ BinPackParameters: false
 BreakBeforeBinaryOperators: false
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializersBeforeComma: true
-ColumnLimit: 120
+ColumnLimit: 100
 CommentPragmas: "^ IWYU pragma:"
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4

.clang-tidy

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

.cmake-format.yaml

@@ -1,247 +0,0 @@
-_help_parse: Options affecting listfile parsing
-parse:
-  _help_additional_commands:
-    - Specify structure for custom cmake functions
-  additional_commands:
-    target_protobuf_sources:
-      pargs:
-        - target
-        - prefix
-      kwargs:
-        PROTOS: "*"
-        LANGUAGE: cpp
-        IMPORT_DIRS: "*"
-        GENERATE_EXTENSIONS: "*"
-        PLUGIN: "*"
-  _help_override_spec:
-    - Override configurations per-command where available
-  override_spec: {}
-  _help_vartags:
-    - Specify variable tags.
-  vartags: []
-  _help_proptags:
-    - Specify property tags.
-  proptags: []
-_help_format: Options affecting formatting.
-format:
-  _help_disable:
-    - Disable formatting entirely, making cmake-format a no-op
-  disable: false
-  _help_line_width:
-    - How wide to allow formatted cmake files
-  line_width: 120
-  _help_tab_size:
-    - How many spaces to tab for indent
-  tab_size: 4
-  _help_use_tabchars:
-    - If true, lines are indented using tab characters (utf-8
-    - 0x09) instead of <tab_size> space characters (utf-8 0x20).
-    - In cases where the layout would require a fractional tab
-    - character, the behavior of the  fractional indentation is
-    - governed by <fractional_tab_policy>
-  use_tabchars: false
-  _help_fractional_tab_policy:
-    - If <use_tabchars> is True, then the value of this variable
-    - indicates how fractional indentions are handled during
-    - whitespace replacement. If set to 'use-space', fractional
-    - indentation is left as spaces (utf-8 0x20). If set to
-    - "`round-up` fractional indentation is replaced with a single"
-    - tab character (utf-8 0x09) effectively shifting the column
-    - to the next tabstop
-  fractional_tab_policy: use-space
-  _help_max_subgroups_hwrap:
-    - If an argument group contains more than this many sub-groups
-    - (parg or kwarg groups) then force it to a vertical layout.
-  max_subgroups_hwrap: 4
-  _help_max_pargs_hwrap:
-    - If a positional argument group contains more than this many
-    - arguments, then force it to a vertical layout.
-  max_pargs_hwrap: 5
-  _help_max_rows_cmdline:
-    - If a cmdline positional group consumes more than this many
-    - lines without nesting, then invalidate the layout (and nest)
-  max_rows_cmdline: 2
-  _help_separate_ctrl_name_with_space:
-    - If true, separate flow control names from their parentheses
-    - with a space
-  separate_ctrl_name_with_space: true
-  _help_separate_fn_name_with_space:
-    - If true, separate function names from parentheses with a
-    - space
-  separate_fn_name_with_space: false
-  _help_dangle_parens:
-    - If a statement is wrapped to more than one line, than dangle
-    - the closing parenthesis on its own line.
-  dangle_parens: false
-  _help_dangle_align:
-    - If the trailing parenthesis must be 'dangled' on its on
-    - "line, then align it to this reference: `prefix`: the start"
-    - "of the statement, `prefix-indent`: the start of the"
-    - "statement, plus one indentation level, `child`: align to"
-    - the column of the arguments
-  dangle_align: prefix
-  _help_min_prefix_chars:
-    - If the statement spelling length (including space and
-    - parenthesis) is smaller than this amount, then force reject
-    - nested layouts.
-  min_prefix_chars: 18
-  _help_max_prefix_chars:
-    - If the statement spelling length (including space and
-    - parenthesis) is larger than the tab width by more than this
-    - amount, then force reject un-nested layouts.
-  max_prefix_chars: 10
-  _help_max_lines_hwrap:
-    - If a candidate layout is wrapped horizontally but it exceeds
-    - this many lines, then reject the layout.
-  max_lines_hwrap: 2
-  _help_line_ending:
-    - What style line endings to use in the output.
-  line_ending: unix
-  _help_command_case:
-    - Format command names consistently as 'lower' or 'upper' case
-  command_case: canonical
-  _help_keyword_case:
-    - Format keywords consistently as 'lower' or 'upper' case
-  keyword_case: unchanged
-  _help_always_wrap:
-    - A list of command names which should always be wrapped
-  always_wrap: []
-  _help_enable_sort:
-    - If true, the argument lists which are known to be sortable
-    - will be sorted lexicographicall
-  enable_sort: true
-  _help_autosort:
-    - If true, the parsers may infer whether or not an argument
-    - list is sortable (without annotation).
-  autosort: true
-  _help_require_valid_layout:
-    - By default, if cmake-format cannot successfully fit
-    - everything into the desired linewidth it will apply the
-    - last, most aggressive attempt that it made. If this flag is
-    - True, however, cmake-format will print error, exit with non-
-    - zero status code, and write-out nothing
-  require_valid_layout: false
-  _help_layout_passes:
-    - A dictionary mapping layout nodes to a list of wrap
-    - decisions. See the documentation for more information.
-  layout_passes: {}
-_help_markup: Options affecting comment reflow and formatting.
-markup:
-  _help_bullet_char:
-    - What character to use for bulleted lists
-  bullet_char: "-"
-  _help_enum_char:
-    - What character to use as punctuation after numerals in an
-    - enumerated list
-  enum_char: .
-  _help_first_comment_is_literal:
-    - If comment markup is enabled, don't reflow the first comment
-    - block in each listfile. Use this to preserve formatting of
-    - your copyright/license statements.
-  first_comment_is_literal: false
-  _help_literal_comment_pattern:
-    - If comment markup is enabled, don't reflow any comment block
-    - which matches this (regex) pattern. Default is `None`
-    - (disabled).
-  literal_comment_pattern: null
-  _help_fence_pattern:
-    - Regular expression to match preformat fences in comments
-    - default= ``r'^\s*([`~]{3}[`~]*)(.*)$'``
-  fence_pattern: ^\s*([`~]{3}[`~]*)(.*)$
-  _help_ruler_pattern:
-    - Regular expression to match rulers in comments default=
-    - '``r''^\s*[^\w\s]{3}.*[^\w\s]{3}$''``'
-  ruler_pattern: ^\s*[^\w\s]{3}.*[^\w\s]{3}$
-  _help_explicit_trailing_pattern:
-    - If a comment line matches starts with this pattern then it
-    - is explicitly a trailing comment for the preceding
-    - argument. Default is '#<'
-  explicit_trailing_pattern: "#<"
-  _help_hashruler_min_length:
-    - If a comment line starts with at least this many consecutive
-    - hash characters, then don't lstrip() them off. This allows
-    - for lazy hash rulers where the first hash char is not
-    - separated by space
-  hashruler_min_length: 10
-  _help_canonicalize_hashrulers:
-    - If true, then insert a space between the first hash char and
-    - remaining hash chars in a hash ruler, and normalize its
-    - length to fill the column
-  canonicalize_hashrulers: true
-  _help_enable_markup:
-    - enable comment markup parsing and reflow
-  enable_markup: false
-_help_lint: Options affecting the linter
-lint:
-  _help_disabled_codes:
-    - a list of lint codes to disable
-  disabled_codes: []
-  _help_function_pattern:
-    - regular expression pattern describing valid function names
-  function_pattern: "[0-9a-z_]+"
-  _help_macro_pattern:
-    - regular expression pattern describing valid macro names
-  macro_pattern: "[0-9A-Z_]+"
-  _help_global_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with global (cache) scope
-  global_var_pattern: "[A-Z][0-9A-Z_]+"
-  _help_internal_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with global scope (but internal semantic)
-  internal_var_pattern: _[A-Z][0-9A-Z_]+
-  _help_local_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with local scope
-  local_var_pattern: "[a-z][a-z0-9_]+"
-  _help_private_var_pattern:
-    - regular expression pattern describing valid names for
-    - privatedirectory variables
-  private_var_pattern: _[0-9a-z_]+
-  _help_public_var_pattern:
-    - regular expression pattern describing valid names for public
-    - directory variables
-  public_var_pattern: "[A-Z][0-9A-Z_]+"
-  _help_argument_var_pattern:
-    - regular expression pattern describing valid names for
-    - function/macro arguments and loop variables.
-  argument_var_pattern: "[a-z][a-z0-9_]+"
-  _help_keyword_pattern:
-    - regular expression pattern describing valid names for
-    - keywords used in functions or macros
-  keyword_pattern: "[A-Z][0-9A-Z_]+"
-  _help_max_conditionals_custom_parser:
-    - In the heuristic for C0201, how many conditionals to match
-    - within a loop in before considering the loop a parser.
-  max_conditionals_custom_parser: 2
-  _help_min_statement_spacing:
-    - Require at least this many newlines between statements
-  min_statement_spacing: 1
-  _help_max_statement_spacing:
-    - Require no more than this many newlines between statements
-  max_statement_spacing: 2
-  max_returns: 6
-  max_branches: 12
-  max_arguments: 5
-  max_localvars: 15
-  max_statements: 50
-_help_encode: Options affecting file encoding
-encode:
-  _help_emit_byteorder_mark:
-    - If true, emit the unicode byte-order mark (BOM) at the start
-    - of the file
-  emit_byteorder_mark: false
-  _help_input_encoding:
-    - Specify the encoding of the input file. Defaults to utf-8
-  input_encoding: utf-8
-  _help_output_encoding:
-    - Specify the encoding of the output file. Defaults to utf-8.
-    - Note that cmake only claims to support utf-8 so be careful
-    - when using anything else
-  output_encoding: utf-8
-_help_misc: Miscellaneous configurations options.
-misc:
-  _help_per_command:
-    - A dictionary containing any per-command configuration
-    - overrides. Currently only `command_case` is supported.
-  per_command: {}

.gersemi/definitions.cmake

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

.gersemirc

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

.github/dependabot.yml

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

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

@@ -4,14 +4,11 @@ Loop: test.jtx test.toplevel
 Loop: test.jtx test.unit_test
   test.unit_test == test.jtx
 
-Loop: xrpld.app xrpld.core
-  xrpld.app > xrpld.core
-
 Loop: xrpld.app xrpld.overlay
-  xrpld.overlay > xrpld.app
+  xrpld.overlay ~= xrpld.app
 
 Loop: xrpld.app xrpld.peerfinder
-  xrpld.peerfinder ~= xrpld.app
+  xrpld.peerfinder == xrpld.app
 
 Loop: xrpld.app xrpld.rpc
   xrpld.rpc > xrpld.app

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

@@ -1,4 +1,6 @@
 libxrpl.basics > xrpl.basics
+libxrpl.conditions > xrpl.basics
+libxrpl.conditions > xrpl.conditions
 libxrpl.core > xrpl.basics
 libxrpl.core > xrpl.core
 libxrpl.crypto > xrpl.basics
@@ -17,16 +19,27 @@ libxrpl.nodestore > xrpl.protocol
 libxrpl.protocol > xrpl.basics
 libxrpl.protocol > xrpl.json
 libxrpl.protocol > xrpl.protocol
+libxrpl.rdb > xrpl.basics
+libxrpl.rdb > xrpl.rdb
 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.rdb
 libxrpl.server > xrpl.server
 libxrpl.shamap > xrpl.basics
 libxrpl.shamap > xrpl.protocol
 libxrpl.shamap > xrpl.shamap
+libxrpl.tx > xrpl.basics
+libxrpl.tx > xrpl.conditions
+libxrpl.tx > xrpl.core
+libxrpl.tx > xrpl.json
+libxrpl.tx > xrpl.ledger
+libxrpl.tx > xrpl.protocol
+libxrpl.tx > xrpl.server
+libxrpl.tx > xrpl.tx
 test.app > test.jtx
 test.app > test.rpc
 test.app > test.toplevel
@@ -41,7 +54,10 @@ test.app > xrpl.json
 test.app > xrpl.ledger
 test.app > xrpl.nodestore
 test.app > xrpl.protocol
+test.app > xrpl.rdb
 test.app > xrpl.resource
+test.app > xrpl.server
+test.app > xrpl.tx
 test.basics > test.jtx
 test.basics > test.unit_test
 test.basics > xrpl.basics
@@ -51,7 +67,7 @@ test.basics > xrpl.json
 test.basics > xrpl.protocol
 test.beast > xrpl.basics
 test.conditions > xrpl.basics
-test.conditions > xrpld.conditions
+test.conditions > xrpl.conditions
 test.consensus > test.csf
 test.consensus > test.toplevel
 test.consensus > test.unit_test
@@ -60,6 +76,7 @@ test.consensus > xrpld.app
 test.consensus > xrpld.consensus
 test.consensus > xrpl.json
 test.consensus > xrpl.ledger
+test.consensus > xrpl.tx
 test.core > test.jtx
 test.core > test.toplevel
 test.core > test.unit_test
@@ -67,6 +84,7 @@ test.core > xrpl.basics
 test.core > xrpl.core
 test.core > xrpld.core
 test.core > xrpl.json
+test.core > xrpl.rdb
 test.core > xrpl.server
 test.csf > xrpl.basics
 test.csf > xrpld.consensus
@@ -75,6 +93,7 @@ test.csf > xrpl.protocol
 test.json > test.jtx
 test.json > xrpl.json
 test.jtx > xrpl.basics
+test.jtx > xrpl.core
 test.jtx > xrpld.app
 test.jtx > xrpld.core
 test.jtx > xrpld.rpc
@@ -84,6 +103,7 @@ 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 > test.toplevel
 test.ledger > xrpl.basics
@@ -95,8 +115,8 @@ test.nodestore > test.jtx
 test.nodestore > test.toplevel
 test.nodestore > test.unit_test
 test.nodestore > xrpl.basics
-test.nodestore > xrpld.core
 test.nodestore > xrpl.nodestore
+test.nodestore > xrpl.rdb
 test.overlay > test.jtx
 test.overlay > test.toplevel
 test.overlay > test.unit_test
@@ -129,8 +149,11 @@ 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.toplevel
 test.server > test.unit_test
@@ -151,40 +174,57 @@ test.unit_test > xrpl.basics
 tests.libxrpl > xrpl.basics
 tests.libxrpl > xrpl.json
 tests.libxrpl > xrpl.net
+xrpl.conditions > xrpl.basics
+xrpl.conditions > xrpl.protocol
 xrpl.core > xrpl.basics
 xrpl.core > xrpl.json
 xrpl.core > xrpl.ledger
+xrpl.core > xrpl.protocol
 xrpl.json > xrpl.basics
 xrpl.ledger > xrpl.basics
 xrpl.ledger > xrpl.protocol
+xrpl.ledger > xrpl.server
+xrpl.ledger > xrpl.shamap
 xrpl.net > xrpl.basics
 xrpl.nodestore > xrpl.basics
 xrpl.nodestore > xrpl.protocol
 xrpl.protocol > xrpl.basics
 xrpl.protocol > xrpl.json
+xrpl.rdb > xrpl.basics
+xrpl.rdb > xrpl.core
+xrpl.rdb > xrpl.protocol
 xrpl.resource > xrpl.basics
 xrpl.resource > xrpl.json
 xrpl.resource > xrpl.protocol
 xrpl.server > xrpl.basics
+xrpl.server > xrpl.core
 xrpl.server > xrpl.json
 xrpl.server > xrpl.protocol
+xrpl.server > xrpl.rdb
+xrpl.server > xrpl.resource
+xrpl.server > xrpl.shamap
 xrpl.shamap > xrpl.basics
 xrpl.shamap > xrpl.nodestore
 xrpl.shamap > xrpl.protocol
+xrpl.tx > xrpl.basics
+xrpl.tx > xrpl.core
+xrpl.tx > xrpl.ledger
+xrpl.tx > xrpl.protocol
 xrpld.app > test.unit_test
 xrpld.app > xrpl.basics
 xrpld.app > xrpl.core
-xrpld.app > xrpld.conditions
 xrpld.app > xrpld.consensus
+xrpld.app > xrpld.core
 xrpld.app > xrpl.json
 xrpld.app > xrpl.ledger
 xrpld.app > xrpl.net
 xrpld.app > xrpl.nodestore
 xrpld.app > xrpl.protocol
+xrpld.app > xrpl.rdb
 xrpld.app > xrpl.resource
+xrpld.app > xrpl.server
 xrpld.app > xrpl.shamap
-xrpld.conditions > xrpl.basics
-xrpld.conditions > xrpl.protocol
+xrpld.app > xrpl.tx
 xrpld.consensus > xrpl.basics
 xrpld.consensus > xrpl.json
 xrpld.consensus > xrpl.protocol
@@ -193,17 +233,21 @@ xrpld.core > xrpl.core
 xrpld.core > xrpl.json
 xrpld.core > xrpl.net
 xrpld.core > xrpl.protocol
+xrpld.core > xrpl.rdb
 xrpld.overlay > xrpl.basics
 xrpld.overlay > xrpl.core
 xrpld.overlay > xrpld.core
 xrpld.overlay > xrpld.peerfinder
 xrpld.overlay > xrpl.json
 xrpld.overlay > xrpl.protocol
+xrpld.overlay > xrpl.rdb
 xrpld.overlay > xrpl.resource
 xrpld.overlay > xrpl.server
+xrpld.overlay > xrpl.tx
 xrpld.peerfinder > xrpl.basics
 xrpld.peerfinder > xrpld.core
 xrpld.peerfinder > xrpl.protocol
+xrpld.peerfinder > xrpl.rdb
 xrpld.perflog > xrpl.basics
 xrpld.perflog > xrpl.core
 xrpld.perflog > xrpld.rpc
@@ -216,6 +260,8 @@ 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.tx
 xrpld.shamap > xrpl.shamap

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

@@ -0,0 +1,10 @@
+name: Check PR title
+
+on:
+  pull_request:
+    types: [opened, edited, reopened, synchronize]
+    branches: [develop]
+
+jobs:
+  check_title:
+    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@943eb8277e8f4b010fde0c826ce4154c36c39509

.github/workflows/on-pr.yml

@@ -33,7 +33,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Determine changed files
         # This step checks whether any files have changed that should
         # cause the next jobs to run. We do it this way rather than
@@ -46,7 +46,7 @@ jobs:
         # that Github considers any skipped jobs to have passed, and in
         # turn the required checks as well.
         id: changes
-        uses: tj-actions/changed-files@ed68ef82c095e0d48ec87eccea555d944a631a4c # v46.0.5
+        uses: tj-actions/changed-files@22103cc46bda19c2b464ffe86db46df6922fd323 # v47.0.5
         with:
           files: |
             # These paths are unique to `on-pr.yml`.
@@ -65,9 +65,12 @@ jobs:
             .github/workflows/reusable-build.yml
             .github/workflows/reusable-build-test-config.yml
             .github/workflows/reusable-build-test.yml
+            .github/workflows/reusable-clang-tidy.yml
+            .github/workflows/reusable-clang-tidy-files.yml
             .github/workflows/reusable-strategy-matrix.yml
             .github/workflows/reusable-test.yml
             .github/workflows/reusable-upload-recipe.yml
+            .clang-tidy
             .codecov.yml
             cmake/**
             conan/**
@@ -107,6 +110,17 @@ jobs:
     if: ${{ needs.should-run.outputs.go == 'true' }}
     uses: ./.github/workflows/reusable-check-rename.yml
 
+  clang-tidy:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-clang-tidy.yml
+    permissions:
+      issues: write
+      contents: read
+    with:
+      check_only_changed: true
+      create_issue_on_failure: false
+
   build-test:
     needs: should-run
     if: ${{ needs.should-run.outputs.go == 'true' }}
@@ -156,6 +170,7 @@ jobs:
     needs:
       - check-levelization
       - check-rename
+      - clang-tidy
       - build-test
       - upload-recipe
       - notify-clio

.github/workflows/on-trigger.yml

@@ -22,9 +22,12 @@ on:
       - ".github/workflows/reusable-build.yml"
       - ".github/workflows/reusable-build-test-config.yml"
       - ".github/workflows/reusable-build-test.yml"
+      - ".github/workflows/reusable-clang-tidy.yml"
+      - ".github/workflows/reusable-clang-tidy-files.yml"
       - ".github/workflows/reusable-strategy-matrix.yml"
       - ".github/workflows/reusable-test.yml"
       - ".github/workflows/reusable-upload-recipe.yml"
+      - ".clang-tidy"
       - ".codecov.yml"
       - "cmake/**"
       - "conan/**"
@@ -60,6 +63,15 @@ defaults:
     shell: bash
 
 jobs:
+  clang-tidy:
+    uses: ./.github/workflows/reusable-clang-tidy.yml
+    permissions:
+      issues: write
+      contents: read
+    with:
+      check_only_changed: false
+      create_issue_on_failure: ${{ github.event_name == 'schedule' }}
+
   build-test:
     uses: ./.github/workflows/reusable-build-test.yml
     strategy:

.github/workflows/pre-commit.yml

@@ -11,7 +11,7 @@ on:
 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@320be44621ca2a080f05aeb15817c44b84518108
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@56de1bdf19639e009639a50b8d17c28ca954f267
     with:
       runs_on: ubuntu-latest
-      container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-ab4d1f0" }'
+      container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'

.github/workflows/publish-docs.yml

@@ -4,6 +4,18 @@ name: Build and publish documentation
 
 on:
   push:
+    branches:
+      - "develop"
+      - "release*"
+    paths:
+      - ".github/workflows/publish-docs.yml"
+      - "*.md"
+      - "**/*.md"
+      - "docs/**"
+      - "include/**"
+      - "src/libxrpl/**"
+      - "src/xrpld/**"
+  pull_request:
     paths:
       - ".github/workflows/publish-docs.yml"
       - "*.md"
@@ -23,17 +35,22 @@ defaults:
 
 env:
   BUILD_DIR: build
-  NPROC_SUBTRACT: 2
+  # 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.private && '1' || '2' }}
 
 jobs:
-  publish:
+  build:
     runs-on: ubuntu-latest
     container: ghcr.io/xrplf/ci/tools-rippled-documentation:sha-a8c7be1
-    permissions:
-      contents: write
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@2cbf481018d930656e9276fcc20dc0e3a0be5b6d
+        with:
+          enable_ccache: false
 
       - name: Get number of processors
         uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
@@ -64,9 +81,23 @@ jobs:
           cmake -Donly_docs=ON ..
           cmake --build . --target docs --parallel ${BUILD_NPROC}
 
-      - name: Publish documentation
-        if: ${{ github.ref_type == 'branch' && github.ref_name == github.event.repository.default_branch }}
-        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
+      - name: Create documentation artifact
+        if: ${{ github.event_name == 'push' }}
+        uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ${{ env.BUILD_DIR }}/docs/html
+          path: ${{ env.BUILD_DIR }}/docs/html
+
+  deploy:
+    if: ${{ 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@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5

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

@@ -101,10 +101,10 @@ jobs:
     steps:
       - name: Cleanup workspace (macOS and Windows)
         if: ${{ runner.os == 'macOS' || runner.os == 'Windows' }}
-        uses: XRPLF/actions/cleanup-workspace@cf0433aa74563aead044a1e395610c96d65a37cf
+        uses: XRPLF/actions/cleanup-workspace@c7d9ce5ebb03c752a354889ecd870cadfc2b1cd4
 
       - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
         uses: XRPLF/actions/prepare-runner@2cbf481018d930656e9276fcc20dc0e3a0be5b6d
@@ -177,7 +177,7 @@ jobs:
 
       - name: Upload the binary (Linux)
         if: ${{ github.repository_owner == 'XRPLF' && runner.os == 'Linux' }}
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: xrpld-${{ inputs.config_name }}
           path: ${{ env.BUILD_DIR }}/xrpld
@@ -229,8 +229,21 @@ jobs:
         env:
           BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
         run: |
-          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}"
+          set -o pipefail
+          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee unittest.log
 
+      - name: Show test failure summary
+        if: ${{ failure() && !inputs.build_only }}
+        working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
+        run: |
+          if [ ! -f unittest.log ]; then
+            echo "unittest.log not found; embedded tests may not have run."
+            exit 0
+          fi
+
+          if ! grep -E "failed" unittest.log; then
+            echo "Log present but no failure lines found in unittest.log."
+          fi
       - name: Debug failure (Linux)
         if: ${{ failure() && runner.os == 'Linux' && !inputs.build_only }}
         run: |
@@ -254,7 +267,7 @@ jobs:
 
       - name: Upload coverage report
         if: ${{ github.repository_owner == 'XRPLF' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
-        uses: codecov/codecov-action@18283e04ce6e62d37312384ff67231eb8fd56d24 # v5.4.3
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
         with:
           disable_search: true
           disable_telem: true

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

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Check levelization
         run: .github/scripts/levelization/generate.sh
       - name: Check for differences

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

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Check definitions
         run: .github/scripts/rename/definitions.sh .
       - name: Check copyright notices

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

@@ -0,0 +1,162 @@
+name: Run clang-tidy on files
+
+on:
+  workflow_call:
+    inputs:
+      files:
+        description: "List of files to check (empty means check all files)"
+        type: string
+        default: ""
+      create_issue_on_failure:
+        description: "Whether to create an issue if the check failed"
+        type: boolean
+        default: false
+
+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
+  BUILD_TYPE: Release
+
+jobs:
+  run-clang-tidy:
+    name: Run clang tidy
+    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
+    container: "ghcr.io/xrplf/ci/debian-trixie:clang-21-sha-53033a2"
+    permissions:
+      issues: write
+      contents: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@2cbf481018d930656e9276fcc20dc0e3a0be5b6d
+        with:
+          enable_ccache: false
+
+      - name: Print build environment
+        uses: ./.github/actions/print-env
+
+      - name: Get number of processors
+        uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
+        id: nproc
+
+      - name: Setup Conan
+        uses: ./.github/actions/setup-conan
+
+      - name: Build dependencies
+        uses: ./.github/actions/build-deps
+        with:
+          build_nproc: ${{ steps.nproc.outputs.nproc }}
+          build_type: ${{ env.BUILD_TYPE }}
+          log_verbosity: verbose
+
+      - name: Configure CMake
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          cmake \
+            -G 'Ninja' \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+            -Dtests=ON \
+            -Dwerr=ON \
+            -Dxrpld=ON \
+            ..
+
+      # clang-tidy needs headers generated from proto files
+      - name: Build libxrpl.libpb
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          ninja -j ${{ steps.nproc.outputs.nproc }} xrpl.libpb
+
+      - name: Run clang tidy
+        id: run_clang_tidy
+        continue-on-error: true
+        env:
+          TARGETS: ${{ inputs.files != '' && inputs.files || 'src tests' }}
+        run: |
+          run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" ${TARGETS} 2>&1 | tee clang-tidy-output.txt
+
+      - name: Upload clang-tidy output
+        if: steps.run_clang_tidy.outcome != 'success'
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: clang-tidy-results
+          path: clang-tidy-output.txt
+          retention-days: 30
+
+      - name: Create an issue
+        if: steps.run_clang_tidy.outcome != 'success' && inputs.create_issue_on_failure
+        id: create_issue
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          # Prepare issue body with clang-tidy output
+          cat > issue.md <<EOF
+          ## Clang-tidy Check Failed
+
+          **Workflow:** ${{ github.workflow }}
+          **Run ID:** ${{ github.run_id }}
+          **Commit:** ${{ github.sha }}
+          **Branch/Ref:** ${{ github.ref }}
+          **Triggered by:** ${{ github.actor }}
+
+          ### Clang-tidy Output:
+          \`\`\`
+          EOF
+
+          # Append clang-tidy output (filter for errors and warnings)
+          if [ -f clang-tidy-output.txt ]; then
+            # Extract lines containing 'error:', 'warning:', or 'note:'
+            grep -E '(error:|warning:|note:)' clang-tidy-output.txt > filtered-output.txt || true
+
+            # If filtered output is empty, use original (might be a different error format)
+            if [ ! -s filtered-output.txt ]; then
+              cp clang-tidy-output.txt filtered-output.txt
+            fi
+
+            # Truncate if too large
+            head -c 60000 filtered-output.txt >> issue.md
+            if [ "$(wc -c < filtered-output.txt)" -gt 60000 ]; then
+              echo "" >> issue.md
+              echo "... (output truncated, see artifacts for full output)" >> issue.md
+            fi
+
+            rm filtered-output.txt
+          else
+            echo "No output file found" >> issue.md
+          fi
+
+          cat >> issue.md <<EOF
+          \`\`\`
+
+          **Workflow run:** ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+
+          ---
+          *This issue was automatically created by the clang-tidy workflow.*
+          EOF
+
+          # Create the issue
+          gh issue create \
+            --label "Bug,Clang-tidy" \
+            --title "Clang-tidy check failed" \
+            --body-file ./issue.md \
+            > create_issue.log
+
+          created_issue="$(sed 's|.*/||' create_issue.log)"
+          echo "created_issue=$created_issue" >> $GITHUB_OUTPUT
+          echo "Created issue #$created_issue"
+
+          rm -f create_issue.log issue.md clang-tidy-output.txt
+
+      - name: Fail the workflow if clang-tidy failed
+        if: steps.run_clang_tidy.outcome != 'success'
+        run: |
+          echo "Clang-tidy check failed!"
+          exit 1

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

@@ -0,0 +1,55 @@
+name: Clang-tidy check
+
+on:
+  workflow_call:
+    inputs:
+      check_only_changed:
+        description: "Check only changed files in PR. If false, checks all files in the repository."
+        type: boolean
+        default: false
+      create_issue_on_failure:
+        description: "Whether to create an issue if the check failed"
+        type: boolean
+        default: false
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  determine-files:
+    name: Determine files to check
+    if: ${{ inputs.check_only_changed }}
+    runs-on: ubuntu-latest
+    outputs:
+      clang_tidy_config_changed: ${{ steps.changed_clang_tidy.outputs.any_changed }}
+      any_cpp_changed: ${{ steps.changed_files.outputs.any_changed }}
+      all_changed_files: ${{ steps.changed_files.outputs.all_changed_files }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Get changed C++ files
+        id: changed_files
+        uses: tj-actions/changed-files@22103cc46bda19c2b464ffe86db46df6922fd323 # v47.0.5
+        with:
+          files: |
+            **/*.cpp
+            **/*.h
+            **/*.ipp
+          separator: " "
+
+      - name: Get changed clang-tidy configuration
+        id: changed_clang_tidy
+        uses: tj-actions/changed-files@22103cc46bda19c2b464ffe86db46df6922fd323 # v47.0.5
+        with:
+          files: |
+            .clang-tidy
+
+  run-clang-tidy:
+    needs: [determine-files]
+    if: ${{ always() && !cancelled() && (!inputs.check_only_changed || needs.determine-files.outputs.any_cpp_changed == 'true' || needs.determine-files.outputs.clang_tidy_config_changed == 'true') }}
+    uses: ./.github/workflows/reusable-clang-tidy-files.yml
+    with:
+      files: ${{ (needs.determine-files.outputs.clang_tidy_config_changed == 'true' && '') || (inputs.check_only_changed && needs.determine-files.outputs.all_changed_files || '') }}
+      create_issue_on_failure: ${{ inputs.create_issue_on_failure }}

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

@@ -29,10 +29,10 @@ jobs:
       matrix: ${{ steps.generate.outputs.matrix }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python
-        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: 3.13
 

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

@@ -43,7 +43,7 @@ jobs:
     container: ghcr.io/xrplf/ci/ubuntu-noble:gcc-13-sha-5dd7158
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Generate build version number
         id: version

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

@@ -64,10 +64,10 @@ jobs:
     steps:
       - name: Cleanup workspace (macOS and Windows)
         if: ${{ runner.os == 'macOS' || runner.os == 'Windows' }}
-        uses: XRPLF/actions/cleanup-workspace@cf0433aa74563aead044a1e395610c96d65a37cf
+        uses: XRPLF/actions/cleanup-workspace@c7d9ce5ebb03c752a354889ecd870cadfc2b1cd4
 
       - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
         uses: XRPLF/actions/prepare-runner@2cbf481018d930656e9276fcc20dc0e3a0be5b6d

.gitignore

@@ -42,6 +42,9 @@ gmon.out
 # Locally patched Conan recipes
 external/conan-center-index/
 
+# Local conan directory
+.conan
+
 # XCode IDE.
 *.pbxuser
 !default.pbxuser
@@ -71,3 +74,9 @@ DerivedData
 /.augment
 /.claude
 /CLAUDE.md
+
+# Direnv's directory
+/.direnv
+
+# clangd cache
+/.cache

.pre-commit-config.yaml

@@ -20,30 +20,29 @@ repos:
         args: [--assume-in-merge]
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: 7d85583be209cb547946c82fbe51f4bc5dd1d017 # frozen: v18.1.8
+    rev: cd481d7b0bfb5c7b3090c21846317f9a8262e891 # frozen: v22.1.0
     hooks:
       - id: clang-format
         args: [--style=file]
         "types_or": [c++, c, proto]
 
-  - repo: https://github.com/cheshirekow/cmake-format-precommit
-    rev: e2c2116d86a80e72e7146a06e68b7c228afc6319 # frozen: v0.6.13
+  - repo: https://github.com/BlankSpruce/gersemi
+    rev: 0.26.0
     hooks:
-      - id: cmake-format
-        additional_dependencies: [PyYAML]
+      - id: gersemi
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: 5ba47274f9b181bce26a5150a725577f3c336011 # frozen: v3.6.2
+    rev: c2bc67fe8f8f549cc489e00ba8b45aa18ee713b1 # frozen: v3.8.1
     hooks:
       - id: prettier
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 831207fd435b47aeffdf6af853097e64322b4d44 # frozen: v25.12.0
+    rev: ea488cebbfd88a5f50b8bd95d5c829d0bb76feb8 # frozen: 26.1.0
     hooks:
       - id: black
 
   - repo: https://github.com/streetsidesoftware/cspell-cli
-    rev: 1cfa010f078c354f3ffb8413616280cc28f5ba21 # frozen: v9.4.0
+    rev: a42085ade523f591dca134379a595e7859986445 # frozen: v9.7.0
     hooks:
       - id: cspell # Spell check changed files
         exclude: .config/cspell.config.yaml
@@ -57,6 +56,24 @@ repos:
           - .git/COMMIT_EDITMSG
         stages: [commit-msg]
 
+  - repo: local
+    hooks:
+      - id: nix-fmt
+        name: Format Nix files
+        entry: |
+          bash -c '
+            if command -v nix &> /dev/null || [ "$GITHUB_ACTIONS" = "true" ]; then
+              nix --extra-experimental-features "nix-command flakes" fmt "$@"
+            else
+              echo "Skipping nix-fmt: nix not installed and not in GitHub Actions"
+              exit 0
+            fi
+          ' --
+        language: system
+        types:
+          - nix
+        pass_filenames: true
+
 exclude: |
   (?x)^(
       external/.*|

API-CHANGELOG.md

@@ -22,6 +22,19 @@ API version 2 is available in `rippled` version 2.0.0 and later. See [API-VERSIO
 
 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.
 
+## Unreleased
+
+This section contains changes targeting a future version.
+
+### Additions
+
+- `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.
+
 ## 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.

CMakeLists.txt

@@ -1,94 +1,84 @@
 cmake_minimum_required(VERSION 3.16)
 
-if (POLICY CMP0074)
+if(POLICY CMP0074)
     cmake_policy(SET CMP0074 NEW)
-endif ()
-if (POLICY CMP0077)
+endif()
+if(POLICY CMP0077)
     cmake_policy(SET CMP0077 NEW)
-endif ()
+endif()
 
 # Fix "unrecognized escape" issues when passing CMAKE_MODULE_PATH on Windows.
-if (DEFINED CMAKE_MODULE_PATH)
+if(DEFINED CMAKE_MODULE_PATH)
     file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
-endif ()
+endif()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 project(xrpl)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 include(CompilationEnv)
 
-if (is_gcc)
+if(is_gcc)
     # GCC-specific fixes
     add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
     # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
-elseif (is_clang)
+elseif(is_clang)
     # Clang-specific fixes
     add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
-elseif (is_msvc)
+elseif(is_msvc)
     # MSVC-specific fixes
     add_compile_options(/wd4068) # Ignore unknown pragmas
-endif ()
+endif()
 
 # Enable ccache to speed up builds.
 include(Ccache)
 
-# make GIT_COMMIT_HASH define available to all sources
-find_package(Git)
-if (Git_FOUND)
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse HEAD
-                    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
-    if (gch)
-        set(GIT_COMMIT_HASH "${gch}")
-        message(STATUS gch: ${GIT_COMMIT_HASH})
-        add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
-    endif ()
-
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse --abbrev-ref HEAD
-                    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
-    if (gb)
-        set(GIT_BRANCH "${gb}")
-        message(STATUS gb: ${GIT_BRANCH})
-        add_definitions(-DGIT_BRANCH="${GIT_BRANCH}")
-    endif ()
-endif () # git
-
-if (thread_safety_analysis)
-    add_compile_options(-Wthread-safety -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
-                        -DXRPL_ENABLE_THREAD_SAFETY_ANNOTATIONS)
+if(thread_safety_analysis)
+    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 ()
+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 ()
+if(target)
+    message(
+        FATAL_ERROR
+        "The target option has been removed - use native cmake options to control build"
+    )
+endif()
 
 include(XrplSanity)
 include(XrplVersion)
 include(XrplSettings)
 # this check has to remain in the top-level cmake because of the early return statement
-if (packages_only)
-    if (NOT TARGET rpm)
-        message(FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?")
-    endif ()
+if(packages_only)
+    if(NOT TARGET rpm)
+        message(
+            FATAL_ERROR
+            "packages_only requested, but targets were not created - is docker installed?"
+        )
+    endif()
     return()
-endif ()
+endif()
 include(XrplCompiler)
 include(XrplSanitizers)
 include(XrplInterface)
 
 option(only_docs "Include only the docs target?" FALSE)
 include(XrplDocs)
-if (only_docs)
+if(only_docs)
     return()
-endif ()
+endif()
 
 include(deps/Boost)
 
@@ -107,41 +97,46 @@ find_package(xxHash REQUIRED)
 
 target_link_libraries(
     xrpl_libs
-    INTERFACE ed25519::ed25519
-              lz4::lz4
-              OpenSSL::Crypto
-              OpenSSL::SSL
-              secp256k1::secp256k1
-              soci::soci
-              SQLite::SQLite3)
+    INTERFACE
+        ed25519::ed25519
+        lz4::lz4
+        OpenSSL::Crypto
+        OpenSSL::SSL
+        secp256k1::secp256k1
+        soci::soci
+        SQLite::SQLite3
+)
 
 option(rocksdb "Enable RocksDB" ON)
-if (rocksdb)
+if(rocksdb)
     find_package(RocksDB REQUIRED)
-    set_target_properties(RocksDB::rocksdb PROPERTIES INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1)
+    set_target_properties(
+        RocksDB::rocksdb
+        PROPERTIES INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1
+    )
     target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
-endif ()
+endif()
 
 # Work around changes to Conan recipe for now.
-if (TARGET nudb::core)
+if(TARGET nudb::core)
     set(nudb nudb::core)
-elseif (TARGET NuDB::nudb)
+elseif(TARGET NuDB::nudb)
     set(nudb NuDB::nudb)
-else ()
+else()
     message(FATAL_ERROR "unknown nudb target")
-endif ()
+endif()
 target_link_libraries(xrpl_libs INTERFACE ${nudb})
 
-if (coverage)
+if(coverage)
     include(XrplCov)
-endif ()
+endif()
 
 set(PROJECT_EXPORT_SET XrplExports)
 include(XrplCore)
 include(XrplInstall)
 include(XrplValidatorKeys)
 
-if (tests)
+if(tests)
     include(CTest)
     add_subdirectory(src/tests/libxrpl)
-endif ()
+endif()

CONTRIBUTING.md

@@ -219,7 +219,7 @@ coherent rather than a set of _thou shalt not_ commandments.
 
 ## Formatting
 
-All code must conform to `clang-format` version 18,
+All code must conform to `clang-format` version 21,
 according to the settings in [`.clang-format`](./.clang-format),
 unless the result would be unreasonably difficult to read or maintain.
 To demarcate lines that should be left as-is, surround them with comments like
@@ -251,6 +251,29 @@ pip3 install pre-commit
 pre-commit install
 ```
 
+## Clang-tidy
+
+All code must pass `clang-tidy` checks according to the settings in [`.clang-tidy`](./.clang-tidy).
+
+There is a Continuous Integration job that runs clang-tidy on pull requests. The CI will check:
+
+- All changed C++ files (`.cpp`, `.h`, `.ipp`) when only code files are modified
+- **All files in the repository** when the `.clang-tidy` configuration file is changed
+
+This ensures that configuration changes don't introduce new warnings across the codebase.
+
+### Running clang-tidy locally
+
+Before running clang-tidy, you must build the project to generate required files (particularly protobuf headers). Refer to [`BUILD.md`](./BUILD.md) for build instructions.
+
+Then run clang-tidy on your local changes:
+
+```
+run-clang-tidy -p build src tests
+```
+
+This will check all source files in the `src` and `tests` directories using the compile commands from your `build` directory.
+
 ## Contracts and instrumentation
 
 We are using [Antithesis](https://antithesis.com/) for continuous fuzzing,

cmake/CMakeFuncs.cmake

@@ -1,29 +1,32 @@
-macro (exclude_from_default target_)
+macro(exclude_from_default target_)
     set_target_properties(${target_} PROPERTIES EXCLUDE_FROM_ALL ON)
     set_target_properties(${target_} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
-endmacro ()
+endmacro()
 
-macro (exclude_if_included target_)
+macro(exclude_if_included target_)
     get_directory_property(has_parent PARENT_DIRECTORY)
-    if (has_parent)
+    if(has_parent)
         exclude_from_default(${target_})
-    endif ()
-endmacro ()
+    endif()
+endmacro()
 
 find_package(Git)
 
-function (git_branch branch_val)
-    if (NOT GIT_FOUND)
+function(git_branch branch_val)
+    if(NOT GIT_FOUND)
         return()
-    endif ()
+    endif()
     set(_branch "")
-    execute_process(COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                    RESULT_VARIABLE _git_exit_code
-                    OUTPUT_VARIABLE _temp_branch
-                    OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
-    if (_git_exit_code EQUAL 0)
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        RESULT_VARIABLE _git_exit_code
+        OUTPUT_VARIABLE _temp_branch
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    if(_git_exit_code EQUAL 0)
         set(_branch ${_temp_branch})
-    endif ()
+    endif()
     set(${branch_val} "${_branch}" PARENT_SCOPE)
-endfunction ()
+endfunction()

cmake/Ccache.cmake

@@ -1,49 +1,62 @@
 find_program(CCACHE_PATH "ccache")
-if (NOT CCACHE_PATH)
+if(NOT CCACHE_PATH)
     return()
-endif ()
+endif()
 
 # For Linux and macOS we can use the ccache binary directly.
-if (NOT MSVC)
+if(NOT MSVC)
     set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PATH}")
     set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PATH}")
     message(STATUS "Found ccache: ${CCACHE_PATH}")
     return()
-endif ()
+endif()
 
 # For Windows more effort is required. The code below is a modified version of
 # https://github.com/ccache/ccache/wiki/MS-Visual-Studio#usage-with-cmake.
-if ("${CCACHE_PATH}" MATCHES "chocolatey")
+if("${CCACHE_PATH}" MATCHES "chocolatey")
     message(DEBUG "Ccache path: ${CCACHE_PATH}")
     # Chocolatey uses a shim executable that we cannot use directly, in which case we have to find the executable it
     # points to. If we cannot find the target executable then we cannot use ccache.
     find_program(BASH_PATH "bash")
-    if (NOT BASH_PATH)
+    if(NOT BASH_PATH)
         message(WARNING "Could not find bash.")
         return()
-    endif ()
+    endif()
 
-    execute_process(COMMAND bash -c
-                            "export LC_ALL='en_US.UTF-8'; ${CCACHE_PATH} --shimgen-noop | grep -oP 'path to executable: \\K.+' | head -c -1"
-                    OUTPUT_VARIABLE CCACHE_PATH)
+    execute_process(
+        COMMAND
+            bash -c
+            "export LC_ALL='en_US.UTF-8'; ${CCACHE_PATH} --shimgen-noop | grep -oP 'path to executable: \\K.+' | head -c -1"
+        OUTPUT_VARIABLE CCACHE_PATH
+    )
 
-    if (NOT CCACHE_PATH)
+    if(NOT CCACHE_PATH)
         message(WARNING "Could not find ccache target.")
         return()
-    endif ()
+    endif()
     file(TO_CMAKE_PATH "${CCACHE_PATH}" CCACHE_PATH)
-endif ()
+endif()
 message(STATUS "Found ccache: ${CCACHE_PATH}")
 
 # Tell cmake to use ccache for compiling with Visual Studio.
 file(COPY_FILE ${CCACHE_PATH} ${CMAKE_BINARY_DIR}/cl.exe ONLY_IF_DIFFERENT)
-set(CMAKE_VS_GLOBALS "CLToolExe=cl.exe" "CLToolPath=${CMAKE_BINARY_DIR}" "TrackFileAccess=false"
-                     "UseMultiToolTask=true")
+set(CMAKE_VS_GLOBALS
+    "CLToolExe=cl.exe"
+    "CLToolPath=${CMAKE_BINARY_DIR}"
+    "TrackFileAccess=false"
+    "UseMultiToolTask=true"
+)
 
 # By default Visual Studio generators will use /Zi to capture debug information, which is not compatible with ccache, so
 # tell it to use /Z7 instead.
-if (MSVC)
-    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
+if(MSVC)
+    foreach(
+        var_
+        CMAKE_C_FLAGS_DEBUG
+        CMAKE_C_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_DEBUG
+        CMAKE_CXX_FLAGS_RELEASE
+    )
         string(REPLACE "/Zi" "/Z7" ${var_} "${${var_}}")
-    endforeach ()
-endif ()
+    endforeach()
+endif()

cmake/CodeCoverage.cmake

@@ -174,36 +174,45 @@ option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)
 # Check prereqs
 find_program(GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
 
-if (DEFINED CODE_COVERAGE_GCOV_TOOL)
+if(DEFINED CODE_COVERAGE_GCOV_TOOL)
     set(GCOV_TOOL "${CODE_COVERAGE_GCOV_TOOL}")
-elseif (DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
+elseif(DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
     set(GCOV_TOOL "$ENV{CODE_COVERAGE_GCOV_TOOL}")
-elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-    if (APPLE)
-        execute_process(COMMAND xcrun -f llvm-cov OUTPUT_VARIABLE LLVMCOV_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
-    else ()
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if(APPLE)
+        execute_process(
+            COMMAND xcrun -f llvm-cov
+            OUTPUT_VARIABLE LLVMCOV_PATH
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+    else()
         find_program(LLVMCOV_PATH llvm-cov)
-    endif ()
-    if (LLVMCOV_PATH)
+    endif()
+    if(LLVMCOV_PATH)
         set(GCOV_TOOL "${LLVMCOV_PATH} gcov")
-    endif ()
-elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+    endif()
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
     find_program(GCOV_PATH gcov)
     set(GCOV_TOOL "${GCOV_PATH}")
-endif ()
+endif()
 
 # Check supported compiler (Clang, GNU and Flang)
 get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
-foreach (LANG ${LANGUAGES})
-    if ("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-        if ("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
-            message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
-        endif ()
-    elseif (NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU" AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES
-                                                                 "(LLVM)?[Ff]lang")
+foreach(LANG ${LANGUAGES})
+    if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+        if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
+            message(
+                FATAL_ERROR
+                "Clang version must be 3.0.0 or greater! Aborting..."
+            )
+        endif()
+    elseif(
+        NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU"
+        AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(LLVM)?[Ff]lang"
+    )
         message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
-    endif ()
-endforeach ()
+    endif()
+endforeach()
 
 set(COVERAGE_COMPILER_FLAGS "-g --coverage" CACHE INTERNAL "")
 
@@ -212,7 +221,7 @@ set(COVERAGE_C_COMPILER_FLAGS "")
 set(COVERAGE_CXX_LINKER_FLAGS "")
 set(COVERAGE_C_LINKER_FLAGS "")
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     include(CheckCXXCompilerFlag)
     include(CheckCCompilerFlag)
     include(CheckLinkerFlag)
@@ -223,51 +232,77 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     set(COVERAGE_C_LINKER_FLAGS ${COVERAGE_COMPILER_FLAGS})
 
     check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
-    if (HAVE_cxx_fprofile_abs_path)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_cxx_fprofile_abs_path)
+        set(COVERAGE_CXX_COMPILER_FLAGS
+            "${COVERAGE_CXX_COMPILER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
-    if (HAVE_c_fprofile_abs_path)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_c_fprofile_abs_path)
+        set(COVERAGE_C_COMPILER_FLAGS
+            "${COVERAGE_C_COMPILER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_linker_flag(CXX -fprofile-abs-path HAVE_cxx_linker_fprofile_abs_path)
-    if (HAVE_cxx_linker_fprofile_abs_path)
-        set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_cxx_linker_fprofile_abs_path)
+        set(COVERAGE_CXX_LINKER_FLAGS
+            "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_linker_flag(C -fprofile-abs-path HAVE_c_linker_fprofile_abs_path)
-    if (HAVE_c_linker_fprofile_abs_path)
-        set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_c_linker_fprofile_abs_path)
+        set(COVERAGE_C_LINKER_FLAGS
+            "${COVERAGE_C_LINKER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_cxx_compiler_flag(-fprofile-update=atomic HAVE_cxx_fprofile_update)
-    if (HAVE_cxx_fprofile_update)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS}  -fprofile-update=atomic")
-    endif ()
+    if(HAVE_cxx_fprofile_update)
+        set(COVERAGE_CXX_COMPILER_FLAGS
+            "${COVERAGE_CXX_COMPILER_FLAGS}  -fprofile-update=atomic"
+        )
+    endif()
 
     check_c_compiler_flag(-fprofile-update=atomic HAVE_c_fprofile_update)
-    if (HAVE_c_fprofile_update)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    if(HAVE_c_fprofile_update)
+        set(COVERAGE_C_COMPILER_FLAGS
+            "${COVERAGE_C_COMPILER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
 
-    check_linker_flag(CXX -fprofile-update=atomic HAVE_cxx_linker_fprofile_update)
-    if (HAVE_cxx_linker_fprofile_update)
-        set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    check_linker_flag(
+        CXX
+        -fprofile-update=atomic
+        HAVE_cxx_linker_fprofile_update
+    )
+    if(HAVE_cxx_linker_fprofile_update)
+        set(COVERAGE_CXX_LINKER_FLAGS
+            "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
 
     check_linker_flag(C -fprofile-update=atomic HAVE_c_linker_fprofile_update)
-    if (HAVE_c_linker_fprofile_update)
-        set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    if(HAVE_c_linker_fprofile_update)
+        set(COVERAGE_C_LINKER_FLAGS
+            "${COVERAGE_C_LINKER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
+endif()
 
-endif ()
-
-get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if (NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
-    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
-endif () # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
+get_property(
+    GENERATOR_IS_MULTI_CONFIG
+    GLOBAL
+    PROPERTY GENERATOR_IS_MULTI_CONFIG
+)
+if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
+    message(
+        WARNING
+        "Code coverage results with an optimised (non-Debug) build may be misleading"
+    )
+endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
@@ -291,123 +326,167 @@ endif () # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 # )
 # The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
 # GCVOR command.
-function (setup_target_for_coverage_gcovr)
+function(setup_target_for_coverage_gcovr)
     set(options NONE)
     set(oneValueArgs BASE_DIRECTORY NAME FORMAT)
     set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
-    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    cmake_parse_arguments(
+        Coverage
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
 
-    if (NOT GCOV_TOOL)
+    if(NOT GCOV_TOOL)
         message(FATAL_ERROR "Could not find gcov or llvm-cov tool! Aborting...")
-    endif ()
+    endif()
 
-    if (NOT GCOVR_PATH)
+    if(NOT GCOVR_PATH)
         message(FATAL_ERROR "Could not find gcovr tool! Aborting...")
-    endif ()
+    endif()
 
     # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
-    if (DEFINED Coverage_BASE_DIRECTORY)
+    if(DEFINED Coverage_BASE_DIRECTORY)
         get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
-    else ()
+    else()
         set(BASEDIR ${PROJECT_SOURCE_DIR})
-    endif ()
+    endif()
 
-    if (NOT DEFINED Coverage_FORMAT)
+    if(NOT DEFINED Coverage_FORMAT)
         set(Coverage_FORMAT xml)
-    endif ()
+    endif()
 
-    if (NOT DEFINED Coverage_EXECUTABLE AND DEFINED Coverage_EXECUTABLE_ARGS)
-        message(FATAL_ERROR "EXECUTABLE_ARGS must not be set if EXECUTABLE is not set")
-    endif ()
+    if(NOT DEFINED Coverage_EXECUTABLE AND DEFINED Coverage_EXECUTABLE_ARGS)
+        message(
+            FATAL_ERROR
+            "EXECUTABLE_ARGS must not be set if EXECUTABLE is not set"
+        )
+    endif()
 
-    if ("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
-        message(FATAL_ERROR "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting...")
-    else ()
-        if ((Coverage_FORMAT STREQUAL "html-details") OR (Coverage_FORMAT STREQUAL "html-nested"))
-            set(GCOVR_OUTPUT_FILE ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html)
+    if("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
+        message(
+            FATAL_ERROR
+            "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting..."
+        )
+    else()
+        if(
+            (Coverage_FORMAT STREQUAL "html-details")
+            OR (Coverage_FORMAT STREQUAL "html-nested")
+        )
+            set(GCOVR_OUTPUT_FILE
+                ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html
+            )
             set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
-        elseif (Coverage_FORMAT STREQUAL "html-single")
+        elseif(Coverage_FORMAT STREQUAL "html-single")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
-        elseif ((Coverage_FORMAT STREQUAL "json-summary") OR (Coverage_FORMAT STREQUAL "json-details")
-                OR (Coverage_FORMAT STREQUAL "coveralls"))
+        elseif(
+            (Coverage_FORMAT STREQUAL "json-summary")
+            OR (Coverage_FORMAT STREQUAL "json-details")
+            OR (Coverage_FORMAT STREQUAL "coveralls")
+        )
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
-        elseif (Coverage_FORMAT STREQUAL "txt")
+        elseif(Coverage_FORMAT STREQUAL "txt")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
-        elseif (Coverage_FORMAT STREQUAL "csv")
+        elseif(Coverage_FORMAT STREQUAL "csv")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
-        elseif (Coverage_FORMAT STREQUAL "lcov")
+        elseif(Coverage_FORMAT STREQUAL "lcov")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
-        else ()
+        else()
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
-        endif ()
-    endif ()
+        endif()
+    endif()
 
-    if ((Coverage_FORMAT STREQUAL "cobertura") OR (Coverage_FORMAT STREQUAL "xml"))
+    if(
+        (Coverage_FORMAT STREQUAL "cobertura")
+        OR (Coverage_FORMAT STREQUAL "xml")
+    )
         list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura-pretty)
         set(Coverage_FORMAT cobertura) # overwrite xml
-    elseif (Coverage_FORMAT STREQUAL "sonarqube")
+    elseif(Coverage_FORMAT STREQUAL "sonarqube")
         list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "jacoco")
+    elseif(Coverage_FORMAT STREQUAL "jacoco")
         list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty)
-    elseif (Coverage_FORMAT STREQUAL "clover")
+    elseif(Coverage_FORMAT STREQUAL "clover")
         list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty)
-    elseif (Coverage_FORMAT STREQUAL "lcov")
+    elseif(Coverage_FORMAT STREQUAL "lcov")
         list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "json-summary")
+    elseif(Coverage_FORMAT STREQUAL "json-summary")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)
-    elseif (Coverage_FORMAT STREQUAL "json-details")
+    elseif(Coverage_FORMAT STREQUAL "json-details")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-pretty)
-    elseif (Coverage_FORMAT STREQUAL "coveralls")
+    elseif(Coverage_FORMAT STREQUAL "coveralls")
         list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls-pretty)
-    elseif (Coverage_FORMAT STREQUAL "csv")
+    elseif(Coverage_FORMAT STREQUAL "csv")
         list(APPEND GCOVR_ADDITIONAL_ARGS --csv "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "txt")
+    elseif(Coverage_FORMAT STREQUAL "txt")
         list(APPEND GCOVR_ADDITIONAL_ARGS --txt "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "html-single")
+    elseif(Coverage_FORMAT STREQUAL "html-single")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-self-contained)
-    elseif (Coverage_FORMAT STREQUAL "html-nested")
+    elseif(Coverage_FORMAT STREQUAL "html-nested")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-nested "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "html-details")
+    elseif(Coverage_FORMAT STREQUAL "html-details")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-details "${GCOVR_OUTPUT_FILE}")
-    else ()
-        message(FATAL_ERROR "Unsupported output style ${Coverage_FORMAT}! Aborting...")
-    endif ()
+    else()
+        message(
+            FATAL_ERROR
+            "Unsupported output style ${Coverage_FORMAT}! Aborting..."
+        )
+    endif()
 
     # Collect excludes (CMake 3.4+: Also compute absolute paths)
     set(GCOVR_EXCLUDES "")
-    foreach (EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
-        if (CMAKE_VERSION VERSION_GREATER 3.4)
-            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
-        endif ()
+    foreach(
+        EXCLUDE
+        ${Coverage_EXCLUDE}
+        ${COVERAGE_EXCLUDES}
+        ${COVERAGE_GCOVR_EXCLUDES}
+    )
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(
+                EXCLUDE
+                ${EXCLUDE}
+                ABSOLUTE
+                BASE_DIR ${BASEDIR}
+            )
+        endif()
         list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
-    endforeach ()
+    endforeach()
     list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
 
     # Combine excludes to several -e arguments
     set(GCOVR_EXCLUDE_ARGS "")
-    foreach (EXCLUDE ${GCOVR_EXCLUDES})
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
         list(APPEND GCOVR_EXCLUDE_ARGS "-e")
         list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
-    endforeach ()
+    endforeach()
 
     # Set up commands which will be run to generate coverage data
     # If EXECUTABLE is not set, the user is expected to run the tests manually
     # before running the coverage target NAME
-    if (DEFINED Coverage_EXECUTABLE)
-        set(GCOVR_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS})
-    endif ()
+    if(DEFINED Coverage_EXECUTABLE)
+        set(GCOVR_EXEC_TESTS_CMD
+            ${Coverage_EXECUTABLE}
+            ${Coverage_EXECUTABLE_ARGS}
+        )
+    endif()
 
     # Create folder
-    if (DEFINED GCOVR_CREATE_FOLDER)
-        set(GCOVR_FOLDER_CMD ${CMAKE_COMMAND} -E make_directory ${GCOVR_CREATE_FOLDER})
-    endif ()
+    if(DEFINED GCOVR_CREATE_FOLDER)
+        set(GCOVR_FOLDER_CMD
+            ${CMAKE_COMMAND}
+            -E
+            make_directory
+            ${GCOVR_CREATE_FOLDER}
+        )
+    endif()
 
     # Running gcovr
     set(GCOVR_CMD
@@ -419,58 +498,95 @@ function (setup_target_for_coverage_gcovr)
         ${BASEDIR}
         ${GCOVR_ADDITIONAL_ARGS}
         ${GCOVR_EXCLUDE_ARGS}
-        --object-directory=${PROJECT_BINARY_DIR})
+        --object-directory=${PROJECT_BINARY_DIR}
+    )
 
-    if (CODE_COVERAGE_VERBOSE)
+    if(CODE_COVERAGE_VERBOSE)
         message(STATUS "Executed command report")
 
-        if (NOT "${GCOVR_EXEC_TESTS_CMD}" STREQUAL "")
+        if(NOT "${GCOVR_EXEC_TESTS_CMD}" STREQUAL "")
             message(STATUS "Command to run tests: ")
-            string(REPLACE ";" " " GCOVR_EXEC_TESTS_CMD_SPACED "${GCOVR_EXEC_TESTS_CMD}")
+            string(
+                REPLACE ";"
+                " "
+                GCOVR_EXEC_TESTS_CMD_SPACED
+                "${GCOVR_EXEC_TESTS_CMD}"
+            )
             message(STATUS "${GCOVR_EXEC_TESTS_CMD_SPACED}")
-        endif ()
+        endif()
 
-        if (NOT "${GCOVR_FOLDER_CMD}" STREQUAL "")
+        if(NOT "${GCOVR_FOLDER_CMD}" STREQUAL "")
             message(STATUS "Command to create a folder: ")
-            string(REPLACE ";" " " GCOVR_FOLDER_CMD_SPACED "${GCOVR_FOLDER_CMD}")
+            string(
+                REPLACE ";"
+                " "
+                GCOVR_FOLDER_CMD_SPACED
+                "${GCOVR_FOLDER_CMD}"
+            )
             message(STATUS "${GCOVR_FOLDER_CMD_SPACED}")
-        endif ()
+        endif()
 
         message(STATUS "Command to generate gcovr coverage data: ")
         string(REPLACE ";" " " GCOVR_CMD_SPACED "${GCOVR_CMD}")
         message(STATUS "${GCOVR_CMD_SPACED}")
-    endif ()
+    endif()
 
-    add_custom_target(${Coverage_NAME}
-                      COMMAND ${GCOVR_EXEC_TESTS_CMD}
-                      COMMAND ${GCOVR_FOLDER_CMD}
-                      COMMAND ${GCOVR_CMD}
-                      BYPRODUCTS ${GCOVR_OUTPUT_FILE}
-                      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-                      DEPENDS ${Coverage_DEPENDENCIES}
-                      VERBATIM # Protect arguments to commands
-                      COMMENT "Running gcovr to produce code coverage report.")
+    add_custom_target(
+        ${Coverage_NAME}
+        COMMAND ${GCOVR_EXEC_TESTS_CMD}
+        COMMAND ${GCOVR_FOLDER_CMD}
+        COMMAND ${GCOVR_CMD}
+        BYPRODUCTS ${GCOVR_OUTPUT_FILE}
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Running gcovr to produce code coverage report."
+    )
 
     # Show info where to find the report
-    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD COMMAND echo
-                       COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}")
-endfunction () # setup_target_for_coverage_gcovr
+    add_custom_command(
+        TARGET ${Coverage_NAME}
+        POST_BUILD
+        COMMAND echo
+        COMMENT
+            "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
+    )
+endfunction() # setup_target_for_coverage_gcovr
 
-function (add_code_coverage_to_target name scope)
-    separate_arguments(COVERAGE_CXX_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_COMPILER_FLAGS}")
-    separate_arguments(COVERAGE_C_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_C_COMPILER_FLAGS}")
-    separate_arguments(COVERAGE_CXX_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_LINKER_FLAGS}")
-    separate_arguments(COVERAGE_C_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_C_LINKER_FLAGS}")
+function(add_code_coverage_to_target name scope)
+    separate_arguments(
+        COVERAGE_CXX_COMPILER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_CXX_COMPILER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_C_COMPILER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_C_COMPILER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_CXX_LINKER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_CXX_LINKER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_C_LINKER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_C_LINKER_FLAGS}"
+    )
 
     # Add compiler options to the target
-    target_compile_options(${name} ${scope} $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
-                           $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
+    target_compile_options(
+        ${name}
+        ${scope}
+        $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
+        $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>
+    )
 
     target_link_libraries(
         ${name}
         ${scope}
-        $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}
-        gcov>
-        $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}
-        gcov>)
-endfunction () # add_code_coverage_to_target
+        $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}>
+        $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}>
+    )
+endfunction() # add_code_coverage_to_target

cmake/CompilationEnv.cmake

@@ -14,20 +14,20 @@ set(is_gcc FALSE)
 set(is_msvc FALSE)
 set(is_xcode FALSE)
 
-if (CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
     set(is_clang TRUE)
-elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(is_gcc TRUE)
-elseif (MSVC)
+elseif(MSVC)
     set(is_msvc TRUE)
-else ()
+else()
     message(FATAL_ERROR "Unsupported C++ compiler: ${CMAKE_CXX_COMPILER_ID}")
-endif ()
+endif()
 
 # Xcode generator detection
-if (CMAKE_GENERATOR STREQUAL "Xcode")
+if(CMAKE_GENERATOR STREQUAL "Xcode")
     set(is_xcode TRUE)
-endif ()
+endif()
 
 # --------------------------------------------------------------------
 # Operating system detection
@@ -36,23 +36,23 @@ set(is_linux FALSE)
 set(is_windows FALSE)
 set(is_macos FALSE)
 
-if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     set(is_linux TRUE)
-elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
     set(is_windows TRUE)
-elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
     set(is_macos TRUE)
-endif ()
+endif()
 
 # --------------------------------------------------------------------
 # Architecture
 # --------------------------------------------------------------------
 set(is_amd64 FALSE)
 set(is_arm64 FALSE)
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
     set(is_amd64 TRUE)
-elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
     set(is_arm64 TRUE)
-else ()
+else()
     message(FATAL_ERROR "Unknown architecture: ${CMAKE_SYSTEM_PROCESSOR}")
-endif ()
+endif()

cmake/GitInfo.cmake

@@ -0,0 +1,28 @@
+include_guard()
+
+set(GIT_BUILD_BRANCH "")
+set(GIT_COMMIT_HASH "")
+
+find_package(Git)
+if(NOT Git_FOUND)
+    message(WARNING "Git not found. Git branch and commit hash will be empty.")
+    return()
+endif()
+
+set(GIT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+
+execute_process(
+    COMMAND
+        ${GIT_EXECUTABLE} --git-dir=${GIT_DIRECTORY} rev-parse --abbrev-ref HEAD
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE GIT_BUILD_BRANCH
+)
+
+execute_process(
+    COMMAND ${GIT_EXECUTABLE} --git-dir=${GIT_DIRECTORY} rev-parse HEAD
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE GIT_COMMIT_HASH
+)
+
+message(STATUS "Git branch: ${GIT_BUILD_BRANCH}")
+message(STATUS "Git commit hash: ${GIT_COMMIT_HASH}")

cmake/XrplAddTest.cmake

@@ -1,13 +1,22 @@
 include(isolate_headers)
 
-function (xrpl_add_test name)
+function(xrpl_add_test name)
     set(target ${PROJECT_NAME}.test.${name})
 
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
-         "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
+        "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
+    )
     add_executable(${target} ${ARGN} ${sources})
 
-    isolate_headers(${target} "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/tests/${name}" PRIVATE)
+    isolate_headers(
+        ${target}
+        "${CMAKE_SOURCE_DIR}"
+        "${CMAKE_SOURCE_DIR}/tests/${name}"
+        PRIVATE
+    )
 
     add_test(NAME ${target} COMMAND ${target})
-endfunction ()
+endfunction()

cmake/XrplCompiler.cmake

@@ -14,31 +14,42 @@ include(XrplSanitizers)
 # add a single global dependency on this interface lib
 link_libraries(Xrpl::common)
 # Respect CMAKE_POSITION_INDEPENDENT_CODE setting (may be set by Conan toolchain)
-if (NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif ()
-set_target_properties(common PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE})
+endif()
+set_target_properties(
+    common
+    PROPERTIES
+        INTERFACE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE}
+)
 set(CMAKE_CXX_EXTENSIONS OFF)
 target_compile_definitions(
     common
-    INTERFACE $<$<CONFIG:Debug>:DEBUG
-              _DEBUG>
-              #[===[
+    INTERFACE
+        $<$<CONFIG:Debug>:DEBUG
+        _DEBUG>
+        #[===[
     NOTE: CMAKE release builds already have NDEBUG defined, so no need to add it
     explicitly except for the special case of (profile ON) and (assert OFF).
     Presumably this is because we don't want profile builds asserting unless
     asserts were specifically requested.
     ]===]
-              $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
-              # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
-              OPENSSL_SUPPRESS_DEPRECATED)
+        $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
+        # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
+        OPENSSL_SUPPRESS_DEPRECATED
+)
 
-if (MSVC)
+if(MSVC)
     # remove existing exception flag since we set it to -EHa
     string(REGEX REPLACE "[-/]EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
-    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
-
+    foreach(
+        var_
+        CMAKE_C_FLAGS_DEBUG
+        CMAKE_C_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_DEBUG
+        CMAKE_CXX_FLAGS_RELEASE
+    )
         # also remove dynamic runtime
         string(REGEX REPLACE "[-/]MD[d]*" " " ${var_} "${${var_}}")
 
@@ -46,117 +57,143 @@ if (MSVC)
         string(REPLACE "/ZI" "/Zi" ${var_} "${${var_}}")
 
         # omit debug info completely under CI (not needed)
-        if (is_ci)
+        if(is_ci)
             string(REPLACE "/Zi" " " ${var_} "${${var_}}")
             string(REPLACE "/Z7" " " ${var_} "${${var_}}")
-        endif ()
-    endforeach ()
+        endif()
+    endforeach()
 
     target_compile_options(
         common
         INTERFACE # Increase object file max size
-                  -bigobj
-                  # Floating point behavior
-                  -fp:precise
-                  # __cdecl calling convention
-                  -Gd
-                  # Minimal rebuild: disabled
-                  -Gm-
-                  # Function level linking: disabled
-                  -Gy-
-                  # Multiprocessor compilation
-                  -MP
-                  # pragma omp: disabled
-                  -openmp-
-                  # No error reporting to Internet
-                  -errorReport:none
-                  # Suppress login banner
-                  -nologo
-                  # Disable signed/unsigned comparison warnings
-                  -wd4018
-                  # Disable float to int possible loss of data warnings
-                  -wd4244
-                  # Disable size_t to T possible loss of data warnings
-                  -wd4267
-                  # Disable C4800(int to bool performance)
-                  -wd4800
-                  # Decorated name length exceeded, name was truncated
-                  -wd4503
-                  $<$<COMPILE_LANGUAGE:CXX>:
-                  -EHa
-                  -GR
-                  >
-                  $<$<CONFIG:Release>:-Ox>
-                  $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
-                  -GS
-                  -Zc:forScope
-                  >
-                  # static runtime
-                  $<$<CONFIG:Debug>:-MTd>
-                  $<$<NOT:$<CONFIG:Debug>>:-MT>
-                  $<$<BOOL:${werr}>:-WX>)
+            -bigobj
+            # Floating point behavior
+            -fp:precise
+            # __cdecl calling convention
+            -Gd
+            # Minimal rebuild: disabled
+            -Gm-
+            # Function level linking: disabled
+            -Gy-
+            # Multiprocessor compilation
+            -MP
+            # pragma omp: disabled
+            -openmp-
+            # No error reporting to Internet
+            -errorReport:none
+            # Suppress login banner
+            -nologo
+            # Disable signed/unsigned comparison warnings
+            -wd4018
+            # Disable float to int possible loss of data warnings
+            -wd4244
+            # Disable size_t to T possible loss of data warnings
+            -wd4267
+            # Disable C4800(int to bool performance)
+            -wd4800
+            # Decorated name length exceeded, name was truncated
+            -wd4503
+            $<$<COMPILE_LANGUAGE:CXX>:
+            -EHa
+            -GR
+            >
+            $<$<CONFIG:Release>:-Ox>
+            $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
+            -GS
+            -Zc:forScope
+            >
+            # static runtime
+            $<$<CONFIG:Debug>:-MTd>
+            $<$<NOT:$<CONFIG:Debug>>:-MT>
+            $<$<BOOL:${werr}>:-WX>
+    )
     target_compile_definitions(
         common
-        INTERFACE _WIN32_WINNT=0x6000
-                  _SCL_SECURE_NO_WARNINGS
-                  _CRT_SECURE_NO_WARNINGS
-                  WIN32_CONSOLE
-                  WIN32_LEAN_AND_MEAN
-                  NOMINMAX
-                  # TODO: Resolve these warnings, don't just silence them
-                  _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
-                  $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:_CRTDBG_MAP_ALLOC>)
+        INTERFACE
+            _WIN32_WINNT=0x6000
+            _SCL_SECURE_NO_WARNINGS
+            _CRT_SECURE_NO_WARNINGS
+            WIN32_CONSOLE
+            WIN32_LEAN_AND_MEAN
+            NOMINMAX
+            # TODO: Resolve these warnings, don't just silence them
+            _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
+            $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:_CRTDBG_MAP_ALLOC>
+    )
     target_link_libraries(common INTERFACE -errorreport:none -machine:X64)
-else ()
+else()
     target_compile_options(
         common
-        INTERFACE -Wall
-                  -Wdeprecated
-                  $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
-                  $<$<BOOL:${wextra}>:-Wextra
-                  -Wno-unused-parameter>
-                  $<$<BOOL:${werr}>:-Werror>
-                  -fstack-protector
-                  -Wno-sign-compare
-                  -Wno-unused-but-set-variable
-                  $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
-                  # tweak gcc optimization for debug
-                  $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
-                  # Add debug symbols to release config
-                  $<$<CONFIG:Release>:-g>)
+        INTERFACE
+            -Wall
+            -Wdeprecated
+            $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
+            $<$<BOOL:${wextra}>:-Wextra
+            -Wno-unused-parameter>
+            $<$<BOOL:${werr}>:-Werror>
+            -fstack-protector
+            -Wno-sign-compare
+            -Wno-unused-but-set-variable
+            $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
+            # tweak gcc optimization for debug
+            $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
+            # Add debug symbols to release config
+            $<$<CONFIG:Release>:-g>
+    )
     target_link_libraries(
         common
-        INTERFACE -rdynamic
-                  $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
-                  # link to static libc/c++ iff: * static option set and * NOT APPLE (AppleClang does not support static
-                  # libc/c++) and * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
-                  $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
-                  -static-libstdc++
-                  -static-libgcc
-                  >)
-endif ()
+        INTERFACE
+            -rdynamic
+            $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
+            # link to static libc/c++ iff: * static option set and * NOT APPLE (AppleClang does not support static
+            # libc/c++) and * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
+            $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
+            -static-libstdc++
+            -static-libgcc
+            >
+    )
+endif()
 
 # Antithesis instrumentation will only be built and deployed using machines running Linux.
-if (voidstar)
-    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
-        message(FATAL_ERROR "Antithesis instrumentation requires Debug build type, aborting...")
-    elseif (NOT is_linux)
-        message(FATAL_ERROR "Antithesis instrumentation requires Linux, aborting...")
-    elseif (NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0))
-        message(FATAL_ERROR "Antithesis instrumentation requires Clang version 16 or later, aborting...")
-    endif ()
-endif ()
+if(voidstar)
+    if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Debug build type, aborting..."
+        )
+    elseif(NOT is_linux)
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Linux, aborting..."
+        )
+    elseif(
+        NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
+    )
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Clang version 16 or later, aborting..."
+        )
+    endif()
+endif()
 
-if (use_mold)
+if(use_mold)
     # use mold linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
-    if ("${LD_VERSION}" MATCHES "mold")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
+    if("${LD_VERSION}" MATCHES "mold")
         target_link_libraries(common INTERFACE -fuse-ld=mold)
-    endif ()
+    endif()
     unset(LD_VERSION)
-elseif (use_gold AND is_gcc)
+elseif(use_gold AND is_gcc)
     # use gold linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
     #[=========================================================[
        NOTE: THE gold linker inserts -rpath as DT_RUNPATH by
        default instead of DT_RPATH, so you might have slightly
@@ -170,31 +207,37 @@ elseif (use_gold AND is_gcc)
        disabling would be to figure out all the settings
        required to make gold play nicely with jemalloc.
     #]=========================================================]
-    if (("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
+    if(("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
         target_link_libraries(
             common
-            INTERFACE -fuse-ld=gold
-                      -Wl,--no-as-needed
-                      #[=========================================================[
+            INTERFACE
+                -fuse-ld=gold
+                -Wl,--no-as-needed
+                #[=========================================================[
            see https://bugs.launchpad.net/ubuntu/+source/eglibc/+bug/1253638/comments/5
            DT_RUNPATH does not work great for transitive
            dependencies (of which boost has a few) - so just
            switch to DT_RPATH if doing dynamic linking with gold
         #]=========================================================]
-                      $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
-    endif ()
+                $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>
+        )
+    endif()
     unset(LD_VERSION)
-elseif (use_lld)
+elseif(use_lld)
     # use lld linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
-    if ("${LD_VERSION}" MATCHES "LLD")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
+    if("${LD_VERSION}" MATCHES "LLD")
         target_link_libraries(common INTERFACE -fuse-ld=lld)
-    endif ()
+    endif()
     unset(LD_VERSION)
-endif ()
+endif()
 
-if (assert)
-    foreach (var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
+if(assert)
+    foreach(var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
         string(REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")
-    endforeach ()
-endif ()
+    endforeach()
+endif()

cmake/XrplConfig.cmake

@@ -3,50 +3,58 @@ include(CMakeFindDependencyMacro)
 #[=========================================================[
   Boost
 #]=========================================================]
-if (static OR APPLE OR MSVC)
+if(static OR APPLE OR MSVC)
     set(Boost_USE_STATIC_LIBS ON)
-endif ()
+endif()
 set(Boost_USE_MULTITHREADED ON)
-if (static OR MSVC)
+if(static OR MSVC)
     set(Boost_USE_STATIC_RUNTIME ON)
-else ()
+else()
     set(Boost_USE_STATIC_RUNTIME OFF)
-endif ()
-find_dependency(Boost
-                COMPONENTS
-                chrono
-                container
-                context
-                coroutine
-                date_time
-                filesystem
-                program_options
-                regex
-                system
-                thread)
+endif()
+find_dependency(
+    Boost
+    COMPONENTS
+    chrono
+    container
+    context
+    coroutine
+    date_time
+    filesystem
+    program_options
+    regex
+    system
+    thread
+)
 #[=========================================================[
   OpenSSL
 #]=========================================================]
-if (NOT DEFINED OPENSSL_ROOT_DIR)
-    if (DEFINED ENV{OPENSSL_ROOT})
+if(NOT DEFINED OPENSSL_ROOT_DIR)
+    if(DEFINED ENV{OPENSSL_ROOT})
         set(OPENSSL_ROOT_DIR $ENV{OPENSSL_ROOT})
-    elseif (APPLE)
+    elseif(APPLE)
         find_program(homebrew brew)
-        if (homebrew)
-            execute_process(COMMAND ${homebrew} --prefix openssl OUTPUT_VARIABLE OPENSSL_ROOT_DIR
-                            OUTPUT_STRIP_TRAILING_WHITESPACE)
-        endif ()
-    endif ()
+        if(homebrew)
+            execute_process(
+                COMMAND ${homebrew} --prefix openssl
+                OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+            )
+        endif()
+    endif()
     file(TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" OPENSSL_ROOT_DIR)
-endif ()
+endif()
 
-if (static OR APPLE OR MSVC)
+if(static OR APPLE OR MSVC)
     set(OPENSSL_USE_STATIC_LIBS ON)
-endif ()
+endif()
 set(OPENSSL_MSVC_STATIC_RT ON)
 find_dependency(OpenSSL REQUIRED)
 find_dependency(ZLIB)
 find_dependency(date)
-if (TARGET ZLIB::ZLIB)
-    set_target_properties(OpenSSL::Crypto PROPERTIES INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
-endif ()
+if(TARGET ZLIB::ZLIB)
+    set_target_properties(
+        OpenSSL::Crypto
+        PROPERTIES INTERFACE_LINK_LIBRARIES ZLIB::ZLIB
+    )
+endif()

cmake/XrplCore.cmake

@@ -10,23 +10,44 @@ include(target_protobuf_sources)
 # so we just build them as a separate library.
 add_library(xrpl.libpb)
 set_target_properties(xrpl.libpb PROPERTIES UNITY_BUILD OFF)
-target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto
-                        PROTOS include/xrpl/proto/xrpl.proto)
+target_protobuf_sources(
+    xrpl.libpb
+    xrpl/proto
+    LANGUAGE cpp
+    IMPORT_DIRS include/xrpl/proto
+    PROTOS include/xrpl/proto/xrpl.proto
+)
 
 file(GLOB_RECURSE protos "include/xrpl/proto/org/*.proto")
-target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto PROTOS "${protos}")
 target_protobuf_sources(
-    xrpl.libpb xrpl/proto
+    xrpl.libpb
+    xrpl/proto
+    LANGUAGE cpp
+    IMPORT_DIRS include/xrpl/proto
+    PROTOS "${protos}"
+)
+target_protobuf_sources(
+    xrpl.libpb
+    xrpl/proto
     LANGUAGE grpc
     IMPORT_DIRS include/xrpl/proto
     PROTOS "${protos}"
     PLUGIN protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
-    GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc)
+    GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc
+)
 
 target_compile_options(
-    xrpl.libpb PUBLIC $<$<BOOL:${is_msvc}>:-wd4996> $<$<BOOL:${is_xcode}>: --system-header-prefix="google/protobuf"
-                      -Wno-deprecated-dynamic-exception-spec >
-    PRIVATE $<$<BOOL:${is_msvc}>:-wd4065> $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>)
+    xrpl.libpb
+    PUBLIC
+        $<$<BOOL:${is_msvc}>:-wd4996>
+        $<$<BOOL:${is_xcode}>:
+        --system-header-prefix="google/protobuf"
+        -Wno-deprecated-dynamic-exception-spec
+        >
+    PRIVATE
+        $<$<BOOL:${is_msvc}>:-wd4065>
+        $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>
+)
 
 target_link_libraries(xrpl.libpb PUBLIC protobuf::libprotobuf gRPC::grpc++)
 
@@ -35,19 +56,21 @@ add_library(xrpl.imports.main INTERFACE)
 
 target_link_libraries(
     xrpl.imports.main
-    INTERFACE absl::random_random
-              date::date
-              ed25519::ed25519
-              LibArchive::LibArchive
-              OpenSSL::Crypto
-              Xrpl::boost
-              Xrpl::libs
-              Xrpl::opts
-              Xrpl::syslibs
-              secp256k1::secp256k1
-              xrpl.libpb
-              xxHash::xxhash
-              $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>)
+    INTERFACE
+        absl::random_random
+        date::date
+        ed25519::ed25519
+        LibArchive::LibArchive
+        OpenSSL::Crypto
+        Xrpl::boost
+        Xrpl::libs
+        Xrpl::opts
+        Xrpl::syslibs
+        secp256k1::secp256k1
+        xrpl.libpb
+        xxHash::xxhash
+        $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
+)
 
 include(add_module)
 include(target_link_modules)
@@ -56,6 +79,16 @@ include(target_link_modules)
 add_module(xrpl beast)
 target_link_libraries(xrpl.libxrpl.beast PUBLIC xrpl.imports.main)
 
+include(GitInfo)
+add_module(xrpl git)
+target_compile_definitions(
+    xrpl.libxrpl.git
+    PRIVATE
+        GIT_COMMIT_HASH="${GIT_COMMIT_HASH}"
+        GIT_BUILD_BRANCH="${GIT_BUILD_BRANCH}"
+)
+target_link_libraries(xrpl.libxrpl.git PUBLIC xrpl.imports.main)
+
 # Level 02
 add_module(xrpl basics)
 target_link_libraries(xrpl.libxrpl.basics PUBLIC xrpl.libxrpl.beast)
@@ -69,11 +102,17 @@ target_link_libraries(xrpl.libxrpl.crypto PUBLIC xrpl.libxrpl.basics)
 
 # Level 04
 add_module(xrpl protocol)
-target_link_libraries(xrpl.libxrpl.protocol PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.json)
+target_link_libraries(
+    xrpl.libxrpl.protocol
+    PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.git xrpl.libxrpl.json
+)
 
 # Level 05
 add_module(xrpl core)
-target_link_libraries(xrpl.libxrpl.core PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
+target_link_libraries(
+    xrpl.libxrpl.core
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
+)
 
 # Level 06
 add_module(xrpl resource)
@@ -81,28 +120,76 @@ target_link_libraries(xrpl.libxrpl.resource PUBLIC xrpl.libxrpl.protocol)
 
 # Level 07
 add_module(xrpl net)
-target_link_libraries(xrpl.libxrpl.net PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
-                                              xrpl.libxrpl.resource)
-
-add_module(xrpl server)
-target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol)
+target_link_libraries(
+    xrpl.libxrpl.net
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.json
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.resource
+)
 
 add_module(xrpl nodestore)
-target_link_libraries(xrpl.libxrpl.nodestore PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
+target_link_libraries(
+    xrpl.libxrpl.nodestore
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
+)
 
 add_module(xrpl shamap)
-target_link_libraries(xrpl.libxrpl.shamap PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.crypto xrpl.libxrpl.protocol
-                                                 xrpl.libxrpl.nodestore)
+target_link_libraries(
+    xrpl.libxrpl.shamap
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.crypto
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.nodestore
+)
+
+add_module(xrpl rdb)
+target_link_libraries(
+    xrpl.libxrpl.rdb
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.core
+)
+
+add_module(xrpl server)
+target_link_libraries(
+    xrpl.libxrpl.server
+    PUBLIC
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.core
+        xrpl.libxrpl.rdb
+        xrpl.libxrpl.resource
+)
+
+add_module(xrpl conditions)
+target_link_libraries(xrpl.libxrpl.conditions PUBLIC xrpl.libxrpl.server)
 
 add_module(xrpl ledger)
-target_link_libraries(xrpl.libxrpl.ledger PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
+target_link_libraries(
+    xrpl.libxrpl.ledger
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.json
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.rdb
+        xrpl.libxrpl.server
+        xrpl.libxrpl.shamap
+        xrpl.libxrpl.conditions
+)
+
+add_module(xrpl tx)
+target_link_libraries(xrpl.libxrpl.tx PUBLIC xrpl.libxrpl.ledger)
 
 add_library(xrpl.libxrpl)
 set_target_properties(xrpl.libxrpl PROPERTIES OUTPUT_NAME xrpl)
 
 add_library(xrpl::libxrpl ALIAS xrpl.libxrpl)
 
-file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp")
+file(
+    GLOB_RECURSE sources
+    CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp"
+)
 target_sources(xrpl.libxrpl PRIVATE ${sources})
 
 target_link_modules(
@@ -110,16 +197,21 @@ target_link_modules(
     PUBLIC
     basics
     beast
+    conditions
     core
     crypto
+    git
     json
+    ledger
+    net
+    nodestore
     protocol
+    rdb
     resource
     server
-    nodestore
     shamap
-    net
-    ledger)
+    tx
+)
 
 # All headers in libxrpl are in modules.
 # Uncomment this stanza if you have not yet moved new headers into a module.
@@ -130,34 +222,51 @@ target_link_modules(
 #     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 #     $<INSTALL_INTERFACE:include>)
 
-if (xrpld)
+if(xrpld)
     add_executable(xrpld)
-    if (tests)
+    if(tests)
         target_compile_definitions(xrpld PUBLIC ENABLE_TESTS)
-        target_compile_definitions(xrpld PRIVATE UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE})
-    endif ()
-    target_include_directories(xrpld PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)
+        target_compile_definitions(
+            xrpld
+            PRIVATE UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
+        )
+    endif()
+    target_include_directories(
+        xrpld
+        PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+    )
 
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp"
+    )
     target_sources(xrpld PRIVATE ${sources})
 
-    if (tests)
-        file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp")
+    if(tests)
+        file(
+            GLOB_RECURSE sources
+            CONFIGURE_DEPENDS
+            "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp"
+        )
         target_sources(xrpld PRIVATE ${sources})
-    endif ()
+    endif()
 
     target_link_libraries(xrpld Xrpl::boost Xrpl::opts Xrpl::libs xrpl.libxrpl)
     exclude_if_included(xrpld)
     # define a macro for tests that might need to
     # be excluded or run differently in CI environment
-    if (is_ci)
+    if(is_ci)
         target_compile_definitions(xrpld PRIVATE XRPL_RUNNING_IN_CI)
-    endif ()
+    endif()
 
-    if (voidstar)
+    if(voidstar)
         target_compile_options(xrpld PRIVATE -fsanitize-coverage=trace-pc-guard)
         # xrpld requires access to antithesis-sdk-cpp implementation file
         # antithesis_instrumentation.h, which is not exported as INTERFACE
-        target_include_directories(xrpld PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk)
-    endif ()
-endif ()
+        target_include_directories(
+            xrpld
+            PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk
+        )
+    endif()
+endif()

cmake/XrplCov.cmake

@@ -2,14 +2,17 @@
    coverage report target
 #]===================================================================]
 
-if (NOT coverage)
+if(NOT coverage)
     message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
-endif ()
+endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
+if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    message(
+        WARNING
+        "Code coverage on Windows is not supported, ignoring 'coverage' flag"
+    )
     return()
-endif ()
+endif()
 
 include(ProcessorCount)
 ProcessorCount(PROCESSOR_COUNT)
@@ -21,32 +24,30 @@ include(CodeCoverage)
 # `CodeCoverage.cmake`)
 
 set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
-if (NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
+if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
     separate_arguments(GCOVR_ADDITIONAL_ARGS)
-endif ()
+endif()
 
-list(APPEND
-     GCOVR_ADDITIONAL_ARGS
-     --exclude-throw-branches
-     --exclude-noncode-lines
-     --exclude-unreachable-branches
-     -s
-     -j
-     ${PROCESSOR_COUNT})
+list(
+    APPEND GCOVR_ADDITIONAL_ARGS
+    --exclude-throw-branches
+    --exclude-noncode-lines
+    --exclude-unreachable-branches
+    -s
+    -j
+    ${PROCESSOR_COUNT}
+)
 
 setup_target_for_coverage_gcovr(
-    NAME
-    coverage
-    FORMAT
-    ${coverage_format}
+    NAME coverage
+    FORMAT ${coverage_format}
     EXCLUDE
-    "src/test"
-    "src/tests"
-    "include/xrpl/beast/test"
-    "include/xrpl/beast/unit_test"
-    "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
-    DEPENDENCIES
-    xrpld
-    xrpl.tests)
+        "src/test"
+        "src/tests"
+        "include/xrpl/beast/test"
+        "include/xrpl/beast/unit_test"
+        "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+    DEPENDENCIES xrpld xrpl.tests
+)
 
 add_code_coverage_to_target(opts INTERFACE)

cmake/XrplDocs.cmake

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

cmake/XrplInstall.cmake

@@ -6,51 +6,71 @@ include(create_symbolic_link)
 
 # If no suffix is defined for executables (e.g. Windows uses .exe but Linux
 # and macOS use none), then explicitly set it to the empty string.
-if (NOT DEFINED suffix)
+if(NOT DEFINED suffix)
     set(suffix "")
-endif ()
+endif()
 
-install(TARGETS common
-                opts
-                xrpl_boost
-                xrpl_libs
-                xrpl_syslibs
-                xrpl.imports.main
-                xrpl.libpb
-                xrpl.libxrpl
-                xrpl.libxrpl.basics
-                xrpl.libxrpl.beast
-                xrpl.libxrpl.core
-                xrpl.libxrpl.crypto
-                xrpl.libxrpl.json
-                xrpl.libxrpl.ledger
-                xrpl.libxrpl.net
-                xrpl.libxrpl.nodestore
-                xrpl.libxrpl.protocol
-                xrpl.libxrpl.resource
-                xrpl.libxrpl.server
-                xrpl.libxrpl.shamap
-                antithesis-sdk-cpp
-        EXPORT XrplExports
-        LIBRARY DESTINATION lib
-        ARCHIVE DESTINATION lib
-        RUNTIME DESTINATION bin
-        INCLUDES
-        DESTINATION include)
+install(
+    TARGETS
+        common
+        opts
+        xrpl_boost
+        xrpl_libs
+        xrpl_syslibs
+        xrpl.imports.main
+        xrpl.libpb
+        xrpl.libxrpl
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.beast
+        xrpl.libxrpl.conditions
+        xrpl.libxrpl.core
+        xrpl.libxrpl.crypto
+        xrpl.libxrpl.git
+        xrpl.libxrpl.json
+        xrpl.libxrpl.rdb
+        xrpl.libxrpl.ledger
+        xrpl.libxrpl.net
+        xrpl.libxrpl.nodestore
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.resource
+        xrpl.libxrpl.server
+        xrpl.libxrpl.shamap
+        xrpl.libxrpl.tx
+        antithesis-sdk-cpp
+    EXPORT XrplExports
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
+)
 
-install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+install(
+    DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl"
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
 
-install(EXPORT XrplExports FILE XrplTargets.cmake NAMESPACE Xrpl:: DESTINATION lib/cmake/xrpl)
+install(
+    EXPORT XrplExports
+    FILE XrplTargets.cmake
+    NAMESPACE Xrpl::
+    DESTINATION lib/cmake/xrpl
+)
 include(CMakePackageConfigHelpers)
-write_basic_package_version_file(XrplConfigVersion.cmake VERSION ${xrpld_version} COMPATIBILITY SameMajorVersion)
+write_basic_package_version_file(
+    XrplConfigVersion.cmake
+    VERSION ${xrpld_version}
+    COMPATIBILITY SameMajorVersion
+)
 
-if (is_root_project AND TARGET xrpld)
+if(is_root_project AND TARGET xrpld)
     install(TARGETS xrpld RUNTIME DESTINATION bin)
     set_target_properties(xrpld PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
     # sample configs should not overwrite existing files
     # install if-not-exists workaround as suggested by
     # https://cmake.org/Bug/view.php?id=12646
-    install(CODE "
+    install(
+        CODE
+            "
     macro (copy_if_not_exists SRC DEST NEWNAME)
       if (NOT EXISTS \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${DEST}/\${NEWNAME}\")
         file (INSTALL FILE_PERMISSIONS OWNER_READ OWNER_WRITE DESTINATION \"\${CMAKE_INSTALL_PREFIX}/\${DEST}\" FILES \"\${SRC}\" RENAME \"\${NEWNAME}\")
@@ -60,14 +80,22 @@ if (is_root_project AND TARGET xrpld)
     endmacro()
     copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/xrpld-example.cfg\" etc xrpld.cfg)
     copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/validators-example.txt\" etc validators.txt)
-  ")
-    install(CODE "
+  "
+    )
+    install(
+        CODE
+            "
     set(CMAKE_MODULE_PATH \"${CMAKE_MODULE_PATH}\")
     include(create_symbolic_link)
     create_symbolic_link(xrpld${suffix} \
        \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/rippled${suffix})
-  ")
-endif ()
+  "
+    )
+endif()
 
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake
-        DESTINATION lib/cmake/xrpl)
+install(
+    FILES
+        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake
+    DESTINATION lib/cmake/xrpl
+)

cmake/XrplInterface.cmake

@@ -5,44 +5,55 @@
 include(CompilationEnv)
 
 # Set defaults for optional variables to avoid uninitialized variable warnings
-if (NOT DEFINED voidstar)
+if(NOT DEFINED voidstar)
     set(voidstar OFF)
-endif ()
+endif()
 
 add_library(opts INTERFACE)
 add_library(Xrpl::opts ALIAS opts)
 target_compile_definitions(
     opts
-    INTERFACE BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
-              BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
-              BOOST_CONTAINER_FWD_BAD_DEQUE
-              HAS_UNCAUGHT_EXCEPTIONS=1
-              $<$<BOOL:${boost_show_deprecated}>:
-              BOOST_ASIO_NO_DEPRECATED
-              BOOST_FILESYSTEM_NO_DEPRECATED
-              >
-              $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
-              BOOST_COROUTINES_NO_DEPRECATION_WARNING
-              BOOST_BEAST_ALLOW_DEPRECATED
-              BOOST_FILESYSTEM_DEPRECATED
-              >
-              $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
-              $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
-              $<$<BOOL:${single_io_service_thread}>:XRPL_SINGLE_IO_SERVICE_THREAD=1>
-              $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>)
+    INTERFACE
+        BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
+        BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+        BOOST_CONTAINER_FWD_BAD_DEQUE
+        HAS_UNCAUGHT_EXCEPTIONS=1
+        $<$<BOOL:${boost_show_deprecated}>:
+        BOOST_ASIO_NO_DEPRECATED
+        BOOST_FILESYSTEM_NO_DEPRECATED
+        >
+        $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
+        BOOST_COROUTINES_NO_DEPRECATION_WARNING
+        BOOST_BEAST_ALLOW_DEPRECATED
+        BOOST_FILESYSTEM_DEPRECATED
+        >
+        $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
+        $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
+        $<$<BOOL:${single_io_service_thread}>:XRPL_SINGLE_IO_SERVICE_THREAD=1>
+        $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>
+)
 target_compile_options(
     opts
-    INTERFACE $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
-              $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized> $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-              $<$<BOOL:${profile}>:-pg> $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+    INTERFACE
+        $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
+        $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
+        $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
+        $<$<BOOL:${profile}>:-pg>
+        $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>
+)
 
-target_link_libraries(opts INTERFACE $<$<BOOL:${profile}>:-pg> $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+target_link_libraries(
+    opts
+    INTERFACE
+        $<$<BOOL:${profile}>:-pg>
+        $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>
+)
 
-if (jemalloc)
+if(jemalloc)
     find_package(jemalloc REQUIRED)
     target_compile_definitions(opts INTERFACE PROFILE_JEMALLOC)
     target_link_libraries(opts INTERFACE jemalloc::jemalloc)
-endif ()
+endif()
 
 #[===================================================================[
    xrpld transitive library deps via an interface library
@@ -52,31 +63,33 @@ add_library(xrpl_syslibs INTERFACE)
 add_library(Xrpl::syslibs ALIAS xrpl_syslibs)
 target_link_libraries(
     xrpl_syslibs
-    INTERFACE $<$<BOOL:${is_msvc}>:
-              legacy_stdio_definitions.lib
-              Shlwapi
-              kernel32
-              user32
-              gdi32
-              winspool
-              comdlg32
-              advapi32
-              shell32
-              ole32
-              oleaut32
-              uuid
-              odbc32
-              odbccp32
-              crypt32
-              >
-              $<$<NOT:$<BOOL:${is_msvc}>>:dl>
-              $<$<NOT:$<OR:$<BOOL:${is_msvc}>,$<BOOL:${is_macos}>>>:rt>)
+    INTERFACE
+        $<$<BOOL:${is_msvc}>:
+        legacy_stdio_definitions.lib
+        Shlwapi
+        kernel32
+        user32
+        gdi32
+        winspool
+        comdlg32
+        advapi32
+        shell32
+        ole32
+        oleaut32
+        uuid
+        odbc32
+        odbccp32
+        crypt32
+        >
+        $<$<NOT:$<BOOL:${is_msvc}>>:dl>
+        $<$<NOT:$<OR:$<BOOL:${is_msvc}>,$<BOOL:${is_macos}>>>:rt>
+)
 
-if (NOT is_msvc)
+if(NOT is_msvc)
     set(THREADS_PREFER_PTHREAD_FLAG ON)
     find_package(Threads)
     target_link_libraries(xrpl_syslibs INTERFACE Threads::Threads)
-endif ()
+endif()
 
 add_library(xrpl_libs INTERFACE)
 add_library(Xrpl::libs ALIAS xrpl_libs)

cmake/XrplSanitizers.cmake

@@ -44,23 +44,26 @@ include(CompilationEnv)
 
 # Read environment variable
 set(SANITIZERS "")
-if (DEFINED ENV{SANITIZERS})
+if(DEFINED ENV{SANITIZERS})
     set(SANITIZERS "$ENV{SANITIZERS}")
-endif ()
+endif()
 
 # Set SANITIZERS_ENABLED flag for use in other modules
-if (SANITIZERS MATCHES "address|thread|undefinedbehavior")
+if(SANITIZERS MATCHES "address|thread|undefinedbehavior")
     set(SANITIZERS_ENABLED TRUE)
-else ()
+else()
     set(SANITIZERS_ENABLED FALSE)
     return()
-endif ()
+endif()
 
 # Sanitizers are not supported on Windows/MSVC
-if (is_msvc)
-    message(FATAL_ERROR "Sanitizers are not supported on Windows/MSVC. "
-                        "Please unset the SANITIZERS environment variable.")
-endif ()
+if(is_msvc)
+    message(
+        FATAL_ERROR
+        "Sanitizers are not supported on Windows/MSVC. "
+        "Please unset the SANITIZERS environment variable."
+    )
+endif()
 
 message(STATUS "Configuring sanitizers: ${SANITIZERS}")
 
@@ -74,24 +77,30 @@ set(san_list "${SANITIZERS}")
 string(REPLACE "," ";" san_list "${san_list}")
 separate_arguments(san_list)
 
-foreach (san IN LISTS san_list)
-    if (san STREQUAL "address")
+foreach(san IN LISTS san_list)
+    if(san STREQUAL "address")
         set(enable_asan TRUE)
-    elseif (san STREQUAL "thread")
+    elseif(san STREQUAL "thread")
         set(enable_tsan TRUE)
-    elseif (san STREQUAL "undefinedbehavior")
+    elseif(san STREQUAL "undefinedbehavior")
         set(enable_ubsan TRUE)
-    else ()
-        message(FATAL_ERROR "Unsupported sanitizer type: ${san}"
-                            "Supported: address, thread, undefinedbehavior and their combinations.")
-    endif ()
-endforeach ()
+    else()
+        message(
+            FATAL_ERROR
+            "Unsupported sanitizer type: ${san}"
+            "Supported: address, thread, undefinedbehavior and their combinations."
+        )
+    endif()
+endforeach()
 
 # Validate sanitizer compatibility
-if (enable_asan AND enable_tsan)
-    message(FATAL_ERROR "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously. "
-                        "Use 'address' or 'thread', optionally with 'undefinedbehavior'.")
-endif ()
+if(enable_asan AND enable_tsan)
+    message(
+        FATAL_ERROR
+        "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously. "
+        "Use 'address' or 'thread', optionally with 'undefinedbehavior'."
+    )
+endif()
 
 # Frame pointer is required for meaningful stack traces. Sanitizers recommend minimum of -O1 for reasonable performance
 set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1")
@@ -99,66 +108,79 @@ set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1")
 # Build the sanitizer flags list
 set(SANITIZER_TYPES)
 
-if (enable_asan)
+if(enable_asan)
     list(APPEND SANITIZER_TYPES "address")
-elseif (enable_tsan)
+elseif(enable_tsan)
     list(APPEND SANITIZER_TYPES "thread")
-endif ()
+endif()
 
-if (enable_ubsan)
+if(enable_ubsan)
     # UB sanitizer flags
     list(APPEND SANITIZER_TYPES "undefined" "float-divide-by-zero")
-    if (is_clang)
+    if(is_clang)
         # Clang supports additional UB checks. More info here
         # https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
         list(APPEND SANITIZER_TYPES "unsigned-integer-overflow")
-    endif ()
-endif ()
+    endif()
+endif()
 
 # Configure code model for GCC on amd64 Use large code model for ASAN to avoid relocation errors Use medium code model
 # for TSAN (large is not compatible with TSAN)
 set(SANITIZERS_RELOCATION_FLAGS)
 
 # Compiler-specific configuration
-if (is_gcc)
+if(is_gcc)
     # Disable mold, gold and lld linkers for GCC with sanitizers Use default linker (bfd/ld) which is more lenient with
     # mixed code models This is needed since the size of instrumented binary exceeds the limits set by mold, lld and
     # gold linkers
     set(use_mold OFF CACHE BOOL "Use mold linker" FORCE)
     set(use_gold OFF CACHE BOOL "Use gold linker" FORCE)
     set(use_lld OFF CACHE BOOL "Use lld linker" FORCE)
-    message(STATUS "  Disabled mold, gold, and lld linkers for GCC with sanitizers")
+    message(
+        STATUS
+        "  Disabled mold, gold, and lld linkers for GCC with sanitizers"
+    )
 
     # Suppress false positive warnings in GCC with stringop-overflow
     list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-stringop-overflow")
 
-    if (is_amd64 AND enable_asan)
+    if(is_amd64 AND enable_asan)
         message(STATUS "  Using large code model (-mcmodel=large)")
         list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=large")
         list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=large")
-    elseif (enable_tsan)
+    elseif(enable_tsan)
         # GCC doesn't support atomic_thread_fence with tsan. Suppress warnings.
         list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-tsan")
         message(STATUS "  Using medium code model (-mcmodel=medium)")
         list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=medium")
         list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=medium")
-    endif ()
+    endif()
 
     # Join sanitizer flags with commas for -fsanitize option
     list(JOIN SANITIZER_TYPES "," SANITIZER_TYPES_STR)
 
     # Add sanitizer to compile and link flags
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
-    set(SANITIZERS_LINK_FLAGS "${SANITIZERS_RELOCATION_FLAGS}" "-fsanitize=${SANITIZER_TYPES_STR}")
-
-elseif (is_clang)
+    set(SANITIZERS_LINK_FLAGS
+        "${SANITIZERS_RELOCATION_FLAGS}"
+        "-fsanitize=${SANITIZER_TYPES_STR}"
+    )
+elseif(is_clang)
     # Add ignorelist for Clang (GCC doesn't support this) Use CMAKE_SOURCE_DIR to get the path to the ignorelist
-    set(IGNORELIST_PATH "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt")
-    if (NOT EXISTS "${IGNORELIST_PATH}")
-        message(FATAL_ERROR "Sanitizer ignorelist not found: ${IGNORELIST_PATH}")
-    endif ()
+    set(IGNORELIST_PATH
+        "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt"
+    )
+    if(NOT EXISTS "${IGNORELIST_PATH}")
+        message(
+            FATAL_ERROR
+            "Sanitizer ignorelist not found: ${IGNORELIST_PATH}"
+        )
+    endif()
 
-    list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize-ignorelist=${IGNORELIST_PATH}")
+    list(
+        APPEND SANITIZERS_COMPILE_FLAGS
+        "-fsanitize-ignorelist=${IGNORELIST_PATH}"
+    )
     message(STATUS "  Using sanitizer ignorelist: ${IGNORELIST_PATH}")
 
     # Join sanitizer flags with commas for -fsanitize option
@@ -167,31 +189,35 @@ elseif (is_clang)
     # Add sanitizer to compile and link flags
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
     set(SANITIZERS_LINK_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
-endif ()
+endif()
 
 message(STATUS "  Compile flags: ${SANITIZERS_COMPILE_FLAGS}")
 message(STATUS "  Link flags: ${SANITIZERS_LINK_FLAGS}")
 
 # Apply the sanitizer flags to the 'common' interface library This is the same library used by XrplCompiler.cmake
-target_compile_options(common INTERFACE $<$<COMPILE_LANGUAGE:CXX>:${SANITIZERS_COMPILE_FLAGS}>
-                                        $<$<COMPILE_LANGUAGE:C>:${SANITIZERS_COMPILE_FLAGS}>)
+target_compile_options(
+    common
+    INTERFACE
+        $<$<COMPILE_LANGUAGE:CXX>:${SANITIZERS_COMPILE_FLAGS}>
+        $<$<COMPILE_LANGUAGE:C>:${SANITIZERS_COMPILE_FLAGS}>
+)
 
 # Apply linker flags
 target_link_options(common INTERFACE ${SANITIZERS_LINK_FLAGS})
 
 # Define SANITIZERS macro for BuildInfo.cpp
 set(sanitizers_list)
-if (enable_asan)
+if(enable_asan)
     list(APPEND sanitizers_list "ASAN")
-endif ()
-if (enable_tsan)
+endif()
+if(enable_tsan)
     list(APPEND sanitizers_list "TSAN")
-endif ()
-if (enable_ubsan)
+endif()
+if(enable_ubsan)
     list(APPEND sanitizers_list "UBSAN")
-endif ()
+endif()
 
-if (sanitizers_list)
+if(sanitizers_list)
     list(JOIN sanitizers_list "." sanitizers_str)
     target_compile_definitions(common INTERFACE SANITIZERS=${sanitizers_str})
-endif ()
+endif()

cmake/XrplSanity.cmake

@@ -7,38 +7,49 @@ include(CompilationEnv)
 get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 
 set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
-if (NOT is_multiconfig)
-    if (NOT CMAKE_BUILD_TYPE)
+if(NOT is_multiconfig)
+    if(NOT CMAKE_BUILD_TYPE)
         message(STATUS "Build type not specified - defaulting to Release")
         set(CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
-    elseif (NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release))
+    elseif(
+        NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release)
+    )
         # for simplicity, these are the only two config types we care about. Limiting the build types simplifies dealing
         # with external project builds especially
-        message(FATAL_ERROR " *** Only Debug or Release build types are currently supported ***")
-    endif ()
-endif ()
+        message(
+            FATAL_ERROR
+            " *** Only Debug or Release build types are currently supported ***"
+        )
+    endif()
+endif()
 
-if (is_clang) # both Clang and AppleClang
-    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
+if(is_clang) # both Clang and AppleClang
+    if(
+        "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+        AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0
+    )
         message(FATAL_ERROR "This project requires clang 16 or later")
-    endif ()
-elseif (is_gcc)
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
+    endif()
+elseif(is_gcc)
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
         message(FATAL_ERROR "This project requires GCC 12 or later")
-    endif ()
-endif ()
+    endif()
+endif()
 
 # check for in-source build and fail
-if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
-    message(FATAL_ERROR "Builds (in-source) are not allowed in "
-                        "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
-                        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory.")
-endif ()
+if("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+    message(
+        FATAL_ERROR
+        "Builds (in-source) are not allowed in "
+        "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
+        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory."
+    )
+endif()
 
-if (MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
+if(MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
     message(FATAL_ERROR "Visual Studio 32-bit build is not supported.")
-endif ()
+endif()
 
-if (APPLE AND NOT HOMEBREW)
+if(APPLE AND NOT HOMEBREW)
     find_program(HOMEBREW brew)
-endif ()
+endif()

cmake/XrplSettings.cmake

@@ -5,59 +5,67 @@
 include(CompilationEnv)
 
 set(is_ci FALSE)
-if (DEFINED ENV{CI})
-    if ("$ENV{CI}" STREQUAL "true")
+if(DEFINED ENV{CI})
+    if("$ENV{CI}" STREQUAL "true")
         set(is_ci TRUE)
-    endif ()
-endif ()
+    endif()
+endif()
 
 get_directory_property(has_parent PARENT_DIRECTORY)
-if (has_parent)
+if(has_parent)
     set(is_root_project OFF)
-else ()
+else()
     set(is_root_project ON)
-endif ()
+endif()
 
 option(assert "Enables asserts, even in release builds" OFF)
 
 option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
-if (tests)
+if(tests)
     # This setting allows making a separate workflow to test fees other than default 10
-    if (NOT UNIT_TEST_REFERENCE_FEE)
+    if(NOT UNIT_TEST_REFERENCE_FEE)
         set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
-    endif ()
-endif ()
+    endif()
+endif()
 
 option(unity "Creates a build using UNITY support in cmake." OFF)
-if (unity)
-    if (NOT is_ci)
+if(unity)
+    if(NOT is_ci)
         set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
-    endif ()
+    endif()
     set(CMAKE_UNITY_BUILD ON CACHE BOOL "Do a unity build")
-endif ()
+endif()
 
-if (is_clang AND is_linux)
+if(is_clang AND is_linux)
     option(voidstar "Enable Antithesis instrumentation." OFF)
-endif ()
+endif()
 
-if (is_gcc OR is_clang)
+if(is_gcc OR is_clang)
     include(ProcessorCount)
     ProcessorCount(PROCESSOR_COUNT)
 
     option(coverage "Generates coverage info." OFF)
     option(profile "Add profiling flags" OFF)
-    set(coverage_format "html-details" CACHE STRING "Output format of the coverage report.")
-    set(coverage_extra_args "" CACHE STRING "Additional arguments to pass to gcovr.")
+    set(coverage_format
+        "html-details"
+        CACHE STRING
+        "Output format of the coverage report."
+    )
+    set(coverage_extra_args
+        ""
+        CACHE STRING
+        "Additional arguments to pass to gcovr."
+    )
     option(wextra "compile with extra gcc/clang warnings enabled" ON)
-else ()
+else()
     set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
     set(coverage OFF CACHE BOOL "gcc/clang only" FORCE)
     set(wextra OFF CACHE BOOL "gcc/clang only" FORCE)
-endif ()
+endif()
 
-if (is_linux AND NOT SANITIZER)
+if(is_linux AND NOT SANITIZER)
     option(BUILD_SHARED_LIBS "build shared xrpl libraries" OFF)
     option(static "link protobuf, openssl, libc++, and boost statically" ON)
     option(perf "Enables flags that assist with perf recording" OFF)
@@ -65,50 +73,83 @@ if (is_linux AND NOT SANITIZER)
     option(use_mold "enables detection of mold (binutils) linker" ON)
     # Set a default value for the log flag based on the build type. This provides a sensible default (on for debug, off
     # for release) while still allowing the user to override it for any build.
-    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
         set(TRUNCATED_LOGS_DEFAULT ON)
-    else ()
+    else()
         set(TRUNCATED_LOGS_DEFAULT OFF)
-    endif ()
-    option(TRUNCATED_THREAD_NAME_LOGS "Show warnings about truncated thread names on Linux." ${TRUNCATED_LOGS_DEFAULT})
-    if (TRUNCATED_THREAD_NAME_LOGS)
+    endif()
+    option(
+        TRUNCATED_THREAD_NAME_LOGS
+        "Show warnings about truncated thread names on Linux."
+        ${TRUNCATED_LOGS_DEFAULT}
+    )
+    if(TRUNCATED_THREAD_NAME_LOGS)
         add_compile_definitions(TRUNCATED_THREAD_NAME_LOGS)
-    endif ()
-else ()
+    endif()
+else()
     # we are not ready to allow shared-libs on windows because it would require export declarations. On macos it's more
     # feasible, but static openssl produces odd linker errors, thus we disable shared lib builds for now.
-    set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared xrpl libraries - OFF for win/macos" FORCE)
+    set(BUILD_SHARED_LIBS
+        OFF
+        CACHE BOOL
+        "build shared xrpl libraries - OFF for win/macos"
+        FORCE
+    )
     set(static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
     set(perf OFF CACHE BOOL "perf flags, linux only" FORCE)
     set(use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
     set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
-endif ()
+endif()
 
-if (is_clang)
+if(is_clang)
     option(use_lld "enables detection of lld linker" ON)
-else ()
+else()
     set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
-endif ()
+endif()
 
 option(jemalloc "Enables jemalloc for heap profiling" OFF)
 option(werr "treat warnings as errors" OFF)
-option(local_protobuf "Force a local build of protobuf instead of looking for an installed version." OFF)
-option(local_grpc "Force a local build of gRPC instead of looking for an installed version." OFF)
+option(
+    local_protobuf
+    "Force a local build of protobuf instead of looking for an installed version."
+    OFF
+)
+option(
+    local_grpc
+    "Force a local build of gRPC instead of looking for an installed version."
+    OFF
+)
 
 # the remaining options are obscure and rarely used
-option(beast_no_unit_test_inline "Prevents unit test definitions from being inserted into global table" OFF)
-option(single_io_service_thread "Restricts the number of threads calling io_context::run to one. \
-  This can be useful when debugging." OFF)
-option(boost_show_deprecated "Allow boost to fail on deprecated usage. Only useful if you're trying\
-  to find deprecated calls." OFF)
+option(
+    beast_no_unit_test_inline
+    "Prevents unit test definitions from being inserted into global table"
+    OFF
+)
+option(
+    single_io_service_thread
+    "Restricts the number of threads calling io_context::run to one. \
+  This can be useful when debugging."
+    OFF
+)
+option(
+    boost_show_deprecated
+    "Allow boost to fail on deprecated usage. Only useful if you're trying\
+  to find deprecated calls."
+    OFF
+)
 
-if (WIN32)
-    option(beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
-else ()
+if(WIN32)
+    option(
+        beast_disable_autolink
+        "Disables autolinking of system libraries on WIN32"
+        OFF
+    )
+else()
     set(beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
-endif ()
+endif()
 
-if (coverage)
+if(coverage)
     message(STATUS "coverage build requested - forcing Debug build")
     set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
-endif ()
+endif()

cmake/XrplValidatorKeys.cmake

@@ -1,17 +1,26 @@
-option(validator_keys "Enables building of validator-keys tool as a separate target (imported via FetchContent)" OFF)
+option(
+    validator_keys
+    "Enables building of validator-keys tool as a separate target (imported via FetchContent)"
+    OFF
+)
 
-if (validator_keys)
+if(validator_keys)
     git_branch(current_branch)
     # default to tracking VK master branch unless we are on release
-    if (NOT (current_branch STREQUAL "release"))
+    if(NOT (current_branch STREQUAL "release"))
         set(current_branch "master")
-    endif ()
+    endif()
     message(STATUS "Tracking ValidatorKeys branch: ${current_branch}")
 
-    FetchContent_Declare(validator_keys GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
-                         GIT_TAG "${current_branch}")
+    FetchContent_Declare(
+        validator_keys
+        GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
+        GIT_TAG "${current_branch}"
+    )
     FetchContent_MakeAvailable(validator_keys)
-    set_target_properties(validator-keys PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+    set_target_properties(
+        validator-keys
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+    )
     install(TARGETS validator-keys RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-endif ()
+endif()

cmake/XrplVersion.cmake

@@ -3,13 +3,13 @@
 #]===================================================================]
 
 file(STRINGS src/libxrpl/protocol/BuildInfo.cpp BUILD_INFO)
-foreach (line_ ${BUILD_INFO})
-    if (line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
+foreach(line_ ${BUILD_INFO})
+    if(line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
         set(xrpld_version ${CMAKE_MATCH_1})
-    endif ()
-endforeach ()
-if (xrpld_version)
+    endif()
+endforeach()
+if(xrpld_version)
     message(STATUS "xrpld version: ${xrpld_version}")
-else ()
+else()
     message(FATAL_ERROR "unable to determine xrpld version")
-endif ()
+endif()

cmake/add_module.cmake

@@ -12,14 +12,29 @@ include(isolate_headers)
 # add_module(parent a)
 # add_module(parent b)
 # target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
-function (add_module parent name)
+function(add_module parent name)
     set(target ${PROJECT_NAME}.lib${parent}.${name})
     add_library(${target} OBJECT)
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp"
+    )
     target_sources(${target} PRIVATE ${sources})
-    target_include_directories(${target} PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/include"
-                    "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}" PUBLIC)
-    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/src" "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
-                    PRIVATE)
-endfunction ()
+    target_include_directories(
+        ${target}
+        PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+    )
+    isolate_headers(
+        ${target}
+        "${CMAKE_CURRENT_SOURCE_DIR}/include"
+        "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}"
+        PUBLIC
+    )
+    isolate_headers(
+        ${target}
+        "${CMAKE_CURRENT_SOURCE_DIR}/src"
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
+        PRIVATE
+    )
+endfunction()

cmake/create_symbolic_link.cmake

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

cmake/deps/Boost.cmake

@@ -1,44 +1,60 @@
 include(CompilationEnv)
 include(XrplSanitizers)
 
-find_package(Boost REQUIRED
-             COMPONENTS chrono
-                        container
-                        coroutine
-                        date_time
-                        filesystem
-                        json
-                        program_options
-                        regex
-                        system
-                        thread)
+find_package(
+    Boost
+    REQUIRED
+    COMPONENTS
+        chrono
+        container
+        coroutine
+        date_time
+        filesystem
+        json
+        program_options
+        regex
+        system
+        thread
+)
 
 add_library(xrpl_boost INTERFACE)
 add_library(Xrpl::boost ALIAS xrpl_boost)
 
 target_link_libraries(
     xrpl_boost
-    INTERFACE Boost::headers
-              Boost::chrono
-              Boost::container
-              Boost::coroutine
-              Boost::date_time
-              Boost::filesystem
-              Boost::json
-              Boost::process
-              Boost::program_options
-              Boost::regex
-              Boost::thread)
-if (Boost_COMPILER)
+    INTERFACE
+        Boost::headers
+        Boost::chrono
+        Boost::container
+        Boost::coroutine
+        Boost::date_time
+        Boost::filesystem
+        Boost::json
+        Boost::process
+        Boost::program_options
+        Boost::regex
+        Boost::thread
+)
+if(Boost_COMPILER)
     target_link_libraries(xrpl_boost INTERFACE Boost::disable_autolinking)
-endif ()
-if (SANITIZERS_ENABLED AND is_clang)
+endif()
+if(SANITIZERS_ENABLED AND is_clang)
     # TODO: gcc does not support -fsanitize-blacklist...can we do something else for gcc ?
-    if (NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
-        get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
-    endif ()
+    if(NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
+        get_target_property(
+            Boost_INCLUDE_DIRS
+            Boost::headers
+            INTERFACE_INCLUDE_DIRECTORIES
+        )
+    endif()
     message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
-    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
-    target_compile_options(opts INTERFACE # ignore boost headers for sanitizing
-                                          -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
-endif ()
+    file(
+        WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt
+        "src:${Boost_INCLUDE_DIRS}/*"
+    )
+    target_compile_options(
+        opts
+        INTERFACE # ignore boost headers for sanitizing
+            -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt
+    )
+endif()

cmake/isolate_headers.cmake

@@ -37,7 +37,7 @@ include(create_symbolic_link)
 # `${CMAKE_CURRENT_BINARY_DIR}/include/${target}`.
 #
 # isolate_headers(target A B scope)
-function (isolate_headers target A B scope)
+function(isolate_headers target A B scope)
     file(RELATIVE_PATH C "${A}" "${B}")
     set(X "${CMAKE_CURRENT_BINARY_DIR}/modules/${target}")
     set(Y "${X}/${C}")
@@ -45,4 +45,4 @@ function (isolate_headers target A B scope)
     file(MAKE_DIRECTORY "${parent}")
     create_symbolic_link("${B}" "${Y}")
     target_include_directories(${target} ${scope} "$<BUILD_INTERFACE:${X}>")
-endfunction ()
+endfunction()

cmake/target_link_modules.cmake

@@ -6,9 +6,9 @@
 # target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
 # add_library(project.libparent)
 # target_link_modules(parent PUBLIC a b)
-function (target_link_modules parent scope)
+function(target_link_modules parent scope)
     set(library ${PROJECT_NAME}.lib${parent})
-    foreach (name ${ARGN})
+    foreach(name ${ARGN})
         set(module ${library}.${name})
         get_target_property(sources ${library} SOURCES)
         list(LENGTH sources before)
@@ -17,8 +17,11 @@ function (target_link_modules parent scope)
         list(REMOVE_ITEM sources ${dupes})
         list(LENGTH sources after)
         math(EXPR actual "${before} - ${after}")
-        message(STATUS "${module} with ${expected} sources took ${actual} sources from ${library}")
+        message(
+            STATUS
+            "${module} with ${expected} sources took ${actual} sources from ${library}"
+        )
         set_target_properties(${library} PROPERTIES SOURCES "${sources}")
         target_link_libraries(${library} ${scope} ${module})
-    endforeach ()
-endfunction ()
+    endforeach()
+endfunction()

cmake/target_protobuf_sources.cmake

@@ -35,20 +35,31 @@ find_package(Protobuf REQUIRED)
 #     This prefix should appear at the start of all your consumer includes.
 # ARGN:
 #     A list of .proto files.
-function (target_protobuf_sources target prefix)
+function(target_protobuf_sources target prefix)
     set(dir "${CMAKE_CURRENT_BINARY_DIR}/pb-${target}")
     file(MAKE_DIRECTORY "${dir}/${prefix}")
 
-    protobuf_generate(TARGET ${target} PROTOC_OUT_DIR "${dir}/${prefix}" "${ARGN}")
+    protobuf_generate(
+        TARGET ${target}
+        PROTOC_OUT_DIR "${dir}/${prefix}"
+        "${ARGN}"
+    )
     target_include_directories(
-        ${target} SYSTEM
+        ${target}
+        SYSTEM
         PUBLIC # Allows #include <package/path/to/file.proto> used by consumer files.
-               $<BUILD_INTERFACE:${dir}>
-               # Allows #include "path/to/file.proto" used by generated files.
-               $<BUILD_INTERFACE:${dir}/${prefix}>
-               # Allows #include <package/path/to/file.proto> used by consumer files.
-               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-               # Allows #include "path/to/file.proto" used by generated files.
-               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>)
-    install(DIRECTORY ${dir}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h")
-endfunction ()
+            $<BUILD_INTERFACE:${dir}>
+            # Allows #include "path/to/file.proto" used by generated files.
+            $<BUILD_INTERFACE:${dir}/${prefix}>
+            # Allows #include <package/path/to/file.proto> used by consumer files.
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+            # Allows #include "path/to/file.proto" used by generated files.
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>
+    )
+    install(
+        DIRECTORY ${dir}/
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        FILES_MATCHING
+        PATTERN "*.h"
+    )
+endfunction()

cspell.config.yaml

@@ -6,6 +6,7 @@ ignorePaths:
   - docs/**/*.puml
   - cmake/**
   - LICENSE.md
+  - .clang-tidy
 language: en
 allowCompoundWords: true # TODO (#6334)
 ignoreRandomStrings: true
@@ -42,6 +43,7 @@ suggestWords:
   - synch->sync
 words:
   - abempty
+  - Agentic
   - AMMID
   - amt
   - amts
@@ -93,6 +95,7 @@ words:
   - desynced
   - determ
   - distro
+  - Emdash
   - doxyfile
   - dxrpl
   - endmacro
@@ -172,6 +175,11 @@ words:
   - nftokens
   - nftpage
   - nikb
+  - nixfmt
+  - nixos
+  - nixpkgs
+  - NOLINT
+  - NOLINTNEXTLINE
   - nonxrp
   - noripple
   - nudb
@@ -248,6 +256,7 @@ words:
   - superpeers
   - takergets
   - takerpays
+  - Tauri
   - ters
   - TMEndpointv2
   - trixie
@@ -287,6 +296,7 @@ words:
   - venv
   - vfalco
   - vinnie
+  - Werror
   - wextra
   - wptr
   - writeme
@@ -303,3 +313,4 @@ words:
   - xrplf
   - xxhash
   - xxhasher
+  - zeroization

docs/ARCHITECTURE.md

@@ -0,0 +1,230 @@
+# rippled Architecture Map
+
+> **Purpose**: Tell agents _where_ things are. Not _why_ they exist.
+> **Audience**: AI coding agents (Claude Code, Codex, Copilot) navigating the codebase.
+> **Principle**: "Give agents a map, not an encyclopedia." — [Harness Engineering](./harness-engineering-report.md)
+
+---
+
+## Layer Diagram
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     RPC Layer (Layer 5)                     │
+│  HTTP/WebSocket → ServerHandler → 72 RPC Handlers           │
+│  src/xrpld/rpc/                                             │
+├─────────────────────────────────────────────────────────────┤
+│                   Application Layer (Layer 4)               │
+│  NetworkOPs · TxQ · PathFinding · LedgerMaster              │
+│  src/xrpld/app/                                             │
+├─────────────────────────────────────────────────────────────┤
+│                   Consensus Layer (Layer 3)                 │
+│  Consensus<Adaptor> · RCLConsensus · Validations            │
+│  src/xrpld/consensus/ + src/xrpld/app/consensus/            │
+├─────────────────────────────────────────────────────────────┤
+│                   Overlay Layer (Layer 2)                   │
+│  OverlayImpl · PeerImp · PeerFinder · Message               │
+│  src/xrpld/overlay/ + src/xrpld/peerfinder/                 │
+├─────────────────────────────────────────────────────────────┤
+│                   Storage Layer (Layer 1)                   │
+│  NodeStore (RocksDB/SQLite) · SHAMap · RDB                  │
+│  src/libxrpl/nodestore/ + src/libxrpl/shamap/               │
+├─────────────────────────────────────────────────────────────┤
+│                   Foundation (Layer 0)                      │
+│  beast:: (I/O, insight, clock) · protocol · crypto · json   │
+│  src/libxrpl/ + include/xrpl/                               │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Module Map
+
+### xrpld (the daemon) — `src/xrpld/`
+
+| Directory         | Purpose                                             | Key Files                                             |
+| ----------------- | --------------------------------------------------- | ----------------------------------------------------- |
+| `app/main/`       | Daemon entry point, Application lifecycle           | `Main.cpp`, `Application.h/.cpp`, `BasicApp.h`        |
+| `app/consensus/`  | Consensus adaptor binding protocol to rippled types | `RCLConsensus.h/.cpp`                                 |
+| `app/ledger/`     | Ledger management, building, acquiring              | `LedgerMaster.h`, `InboundLedgers.h`                  |
+| `app/misc/`       | NetworkOPs, TxQ, HashRouter, Amendments             | `NetworkOPs.h/.cpp`, `TxQ.h`, `HashRouter.h`          |
+| `app/tx/`         | Transaction application engine                      | `apply.h/.cpp`, `applySteps.h`                        |
+| `app/paths/`      | Payment path finding                                | `Pathfinder.h`, `PathRequest.h`                       |
+| `app/rdb/`        | Relational DB backend for state                     | `RelationalDatabase.h`                                |
+| `consensus/`      | Generic consensus protocol (template-based)         | `Consensus.h/.cpp`, `ConsensusParms.h`                |
+| `core/`           | Node configuration, time keeping                    | `Config.h/.cpp`, `TimeKeeper.h`                       |
+| `overlay/`        | P2P network: peer connections, message routing      | `Overlay.h`, `Peer.h`, `Message.h`                    |
+| `overlay/detail/` | Overlay implementation internals                    | `OverlayImpl.h/.cpp`, `PeerImp.h/.cpp`, `Handshake.h` |
+| `peerfinder/`     | Peer discovery and bootstrap                        | `PeerfinderManager.h`, `detail/Logic.h`               |
+| `perflog/`        | Performance logging (pre-OTel telemetry)            | `detail/PerfLogImp.h/.cpp`                            |
+| `rpc/`            | JSON-RPC server and routing                         | `detail/Handler.h`, `RPCHandler.h`                    |
+| `rpc/handlers/`   | **72 RPC command implementations**                  | `AccountInfo.cpp`, `Submit.cpp`, `Tx.cpp`, etc.       |
+| `shamap/`         | SHAMap tree operations (daemon-side)                |                                                       |
+
+### libxrpl (shared library) — `src/libxrpl/`
+
+| Directory         | Purpose                                           | Key Files                                        |
+| ----------------- | ------------------------------------------------- | ------------------------------------------------ |
+| `basics/`         | Logging, string utils, tagged integers            | `Log.cpp` (log formatting — Phase 8 OTel target) |
+| `beast/insight/`  | Metrics framework (StatsD, Gauge, Counter, Event) | `StatsDCollector.cpp` (Phase 6-7 OTel target)    |
+| `beast/core/`     | Async I/O primitives                              | `CurrentThreadName.cpp`                          |
+| `core/`           | Crypto, seed handling                             |                                                  |
+| `crypto/`         | Ed25519, secp256k1, SHA                           |                                                  |
+| `json/`           | JSON parser/writer                                |                                                  |
+| `nodestore/`      | Key-value storage for ledger nodes                | `backend/RocksDBFactory.cpp`                     |
+| `protocol/`       | XRPL protocol: serialization, STObject, STTx      | `STTx.cpp`, `STObject.cpp`                       |
+| `server/`         | HTTP/WebSocket server core                        | `ServerHandler.h`                                |
+| `tx/transactors/` | Per-transaction-type execution logic              | `Payment.cpp`, `CreateOffer.cpp`, etc.           |
+| `tx/invariants/`  | Transaction invariant checks                      | `TransactionCheck.cpp`                           |
+
+### Public Headers — `include/xrpl/`
+
+Mirrors `src/libxrpl/` structure. Agent-accessible API surface for external consumers of libxrpl.
+
+Key subdirectory: `include/xrpl/proto/org/xrpl/rpc/v1/` — Protocol Buffer definitions for gRPC API.
+
+---
+
+## Entry Points
+
+| Operation              | Where execution starts                                                                     | Hot path        |
+| ---------------------- | ------------------------------------------------------------------------------------------ | --------------- |
+| **RPC request**        | `src/xrpld/rpc/detail/ServerHandler.cpp` → handler lookup → `src/xrpld/rpc/handlers/*.cpp` | Layer 5 → 4     |
+| **Peer message**       | `src/xrpld/overlay/detail/PeerImp.cpp::onMessage()` → message-type dispatch                | Layer 2 → 3/4   |
+| **Transaction submit** | `rpc/handlers/Submit.cpp` → `app/misc/NetworkOPs.cpp::submitTransaction()`                 | Layer 5 → 4 → 2 |
+| **Transaction relay**  | `overlay/detail/PeerImp.cpp::handleTransaction()` → `NetworkOPs::processTransaction()`     | Layer 2 → 4     |
+| **Consensus round**    | `app/consensus/RCLConsensus.cpp::startRound()` → phase transitions → accept                | Layer 3         |
+| **Ledger close**       | `RCLConsensus.cpp::onClose()` → `acceptLedger()` → apply transactions                      | Layer 3 → 4 → 1 |
+| **Ledger acquire**     | `app/ledger/InboundLedgers.cpp::acquire()` → peer fetch → SHAMap                           | Layer 4 → 2 → 1 |
+| **Startup**            | `app/main/Main.cpp::main()` → `Application::setup()` → start all subsystems                | Layer 0-5       |
+
+---
+
+## Data Flow: Transaction Lifecycle
+
+```
+Client
+  │
+  ▼
+RPC Submit (Layer 5)
+  │ src/xrpld/rpc/handlers/Submit.cpp
+  ▼
+NetworkOPs::submitTransaction() (Layer 4)
+  │ src/xrpld/app/misc/NetworkOPs.cpp
+  ├──▶ TxQ::apply() — queue management
+  │     src/xrpld/app/misc/TxQ.cpp
+  ├──▶ HashRouter::setFlags() — deduplication
+  │     src/xrpld/app/misc/HashRouter.cpp
+  ▼
+Overlay::relay() (Layer 2)
+  │ src/xrpld/overlay/detail/OverlayImpl.cpp
+  ├──▶ PeerImp::send() — to each connected peer
+  │     src/xrpld/overlay/detail/PeerImp.cpp
+  ▼
+[Remote Node] PeerImp::handleTransaction() (Layer 2)
+  │ src/xrpld/overlay/detail/PeerImp.cpp
+  ▼
+Consensus::startRound() (Layer 3)
+  │ src/xrpld/consensus/Consensus.h
+  │ src/xrpld/app/consensus/RCLConsensus.cpp
+  ├──▶ propose() — send position to peers
+  ├──▶ onClose() — close the ledger
+  ▼
+acceptLedger() → applyTransactions() (Layer 3 → 1)
+  │ src/xrpld/app/consensus/RCLConsensus.cpp
+  ▼
+NodeStore::store() (Layer 1)
+  │ src/libxrpl/nodestore/
+```
+
+---
+
+## Build Targets
+
+| Target               | Type                      | Source                           |
+| -------------------- | ------------------------- | -------------------------------- |
+| `xrpl`               | Shared library (libxrpl)  | `src/libxrpl/` + `include/xrpl/` |
+| `xrpld`              | Executable (daemon)       | `src/xrpld/`                     |
+| `rippled_unit_tests` | Unit test binary          | `src/test/`                      |
+| `libxrpl_tests`      | Library integration tests | `src/tests/libxrpl/`             |
+
+**Build command**: `cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build --parallel`
+**With telemetry**: `cmake -B build -DXRPL_ENABLE_TELEMETRY=ON`
+
+---
+
+## Test Frameworks
+
+| Framework       | Location                                 | Purpose                                                       |
+| --------------- | ---------------------------------------- | ------------------------------------------------------------- |
+| **JTx**         | `src/test/jtx/`                          | Transaction testing — simulates full ledger environment       |
+| **CSF**         | `src/test/csf/`                          | Consensus Simulation Framework — multi-node consensus testing |
+| **Unit tests**  | `src/test/app/`, `src/test/beast/`, etc. | Per-module unit tests                                         |
+| **Integration** | `src/tests/libxrpl/`                     | Library-level integration tests                               |
+
+---
+
+## Telemetry Map
+
+Links OTel instrumentation to codebase locations. See [09-data-collection-reference.md](../../OpenTelemetryPlan/09-data-collection-reference.md) for the full inventory.
+
+| Span          | Source Location                            | Layer |
+| ------------- | ------------------------------------------ | ----- |
+| `rpc.*`       | `src/xrpld/rpc/detail/ServerHandler.cpp`   | 5     |
+| `tx.submit`   | `src/xrpld/app/misc/NetworkOPs.cpp`        | 4     |
+| `tx.relay`    | `src/xrpld/overlay/detail/PeerImp.cpp`     | 2     |
+| `peer.send`   | `src/xrpld/overlay/detail/PeerImp.cpp`     | 2     |
+| `consensus.*` | `src/xrpld/app/consensus/RCLConsensus.cpp` | 3     |
+| `ledger.*`    | `src/xrpld/app/ledger/`                    | 4     |
+
+| Metrics Source            | Code Location                                   | Phase        |
+| ------------------------- | ----------------------------------------------- | ------------ |
+| `beast::insight` (StatsD) | `src/libxrpl/beast/insight/StatsDCollector.cpp` | 6-7          |
+| SpanMetrics (derived)     | OTel Collector config                           | 5            |
+| PerfLog                   | `src/xrpld/perflog/detail/PerfLogImp.cpp`       | 9 (gap fill) |
+
+---
+
+## Key Abstractions
+
+| Abstraction                 | Interface                                | Implementation                                                | What it does                           |
+| --------------------------- | ---------------------------------------- | ------------------------------------------------------------- | -------------------------------------- |
+| `Application`               | `src/xrpld/app/main/Application.h`       | `Application.cpp`                                             | Wires all subsystems together          |
+| `Overlay`                   | `src/xrpld/overlay/Overlay.h`            | `detail/OverlayImpl.cpp`                                      | Manages P2P connections                |
+| `Consensus<>`               | `src/xrpld/consensus/Consensus.h`        | Template, adaptor in `RCLConsensus.cpp`                       | Generic consensus protocol             |
+| `NetworkOPs`                | `src/xrpld/app/misc/NetworkOPs.h`        | `NetworkOPs.cpp`                                              | Transaction processing, event dispatch |
+| `LedgerMaster`              | `src/xrpld/app/ledger/LedgerMaster.h`    | `LedgerMaster.cpp`                                            | Ledger lifecycle management            |
+| `NodeStore`                 | `include/xrpl/nodestore/Database.h`      | `src/libxrpl/nodestore/`                                      | Persistent key-value storage           |
+| `beast::insight::Collector` | `include/xrpl/beast/insight/Collector.h` | `StatsDCollector`, `NullCollector`, (future: `OTelCollector`) | Metrics collection interface           |
+| `JobQueue`                  | `src/xrpld/core/JobQueue.h`              | `JobQueue.cpp`                                                | Async task scheduling                  |
+| `SHAMap`                    | `include/xrpl/shamap/SHAMap.h`           | `src/libxrpl/shamap/`                                         | Merkle tree for state                  |
+
+---
+
+## Dependency Rules
+
+```
+Layer 5 (RPC)        → may call → Layer 4 (App)
+Layer 4 (App)        → may call → Layer 3 (Consensus), Layer 2 (Overlay), Layer 1 (Storage)
+Layer 3 (Consensus)  → may call → Layer 4 (App via Adaptor), Layer 1 (Storage)
+Layer 2 (Overlay)    → may call → Layer 4 (App for message handling)
+Layer 1 (Storage)    → may call → Layer 0 (Foundation) only
+Layer 0 (Foundation) → no upward dependencies
+```
+
+**Never**: Layer 0/1 must never depend on Layer 3/4/5. Layer 5 must never bypass Layer 4 to reach Layer 2/3 directly.
+
+---
+
+## Configuration
+
+| File                    | Location | Purpose                   |
+| ----------------------- | -------- | ------------------------- |
+| `xrpld.cfg`             | `cfg/`   | Main daemon configuration |
+| `validators.txt`        | `cfg/`   | Validator list            |
+| `CMakeUserPresets.json` | Root     | Local build presets       |
+| `conanfile.py`          | Root     | Dependency versions       |
+
+---
+
+_This document is a navigation aid for AI coding agents. For architectural rationale, see [docs/consensus.md](consensus.md). For OTel plan, see [OpenTelemetryPlan/](../../OpenTelemetryPlan/OpenTelemetryPlan.md). For coding conventions, see [docs/CodingStyle.md](CodingStyle.md)._

docs/CodingStyle.md

@@ -17,8 +17,8 @@ guideline is to maintain the standards that are used in those libraries.
 ## Guidelines
 
 If you want to do something contrary to these guidelines, understand
-why you're doing it. Think, use common sense, and consider that this
-your changes will probably need to be maintained long after you've
+why you're doing it. Think, use common sense, and consider that these
+changes will probably need to be maintained long after you've
 moved on to other projects.
 
 - Use white space and blank lines to guide the eye and keep your intent clear.

docs/WORKFLOW.md

@@ -0,0 +1,196 @@
+---
+# Symphony-compatible workflow definition for rippled
+# See: https://github.com/openai/symphony/blob/main/SPEC.md
+# See: docs/harness-engineering-report.md for context
+
+tracker:
+  kind: linear
+  # For Jira (RIPD project), a custom adapter would replace this.
+  # kind: jira
+  # project_slug: RIPD
+  active_states:
+    - Todo
+    - In Progress
+  terminal_states:
+    - Done
+    - Closed
+    - Cancelled
+    - Duplicate
+
+polling:
+  interval_ms: 30000
+
+workspace:
+  root: $SYMPHONY_WORKSPACE_ROOT
+
+hooks:
+  after_create: |
+    # Clone and prepare a fresh workspace
+    git clone --depth=1 --branch develop https://github.com/XRPLF/rippled.git .
+    # Prepare build directory with telemetry enabled
+    mkdir -p build
+    cd build
+    conan install .. --output-folder=. --build=missing
+    cmake .. -DCMAKE_BUILD_TYPE=Debug -DXRPL_ENABLE_TELEMETRY=ON -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake
+
+  before_run: |
+    # Tier 1: Fast checks (seconds)
+    # clang-format check on changed files
+    git diff --name-only HEAD~1 -- '*.cpp' '*.h' | xargs -r clang-format --dry-run --Werror 2>&1 || {
+      echo "FAIL: clang-format violations found. Fix formatting before proceeding."
+      exit 1
+    }
+
+    # Tier 2: Build (minutes)
+    cd build
+    cmake --build . --parallel $(nproc) 2>&1 || {
+      echo "FAIL: Build failed. Check compiler errors above."
+      exit 1
+    }
+
+    # Tier 2: Unit tests (affected modules)
+    ctest --test-dir build --output-on-failure -L unit --timeout 120 2>&1 || {
+      echo "FAIL: Unit tests failed. Check test output above."
+      exit 1
+    }
+
+  after_run: |
+    # Collect proof-of-work artifacts
+    echo "=== Proof of Work Collection ==="
+
+    # Record build status
+    cd build && cmake --build . --parallel $(nproc) 2>&1
+    BUILD_STATUS=$?
+    echo "Build status: $BUILD_STATUS"
+
+    # Run telemetry integration tests if available
+    if ctest --test-dir build -L telemetry --timeout 300 2>&1; then
+      echo "Telemetry integration tests: PASSED"
+    else
+      echo "Telemetry integration tests: FAILED (non-blocking)"
+    fi
+
+    # Capture complexity metrics
+    echo "=== Changed Files ==="
+    git diff --stat HEAD~1
+
+  timeout_ms: 120000
+
+agent:
+  max_concurrent_agents: 3
+  max_retry_backoff_ms: 300000
+  max_concurrent_agents_by_state:
+    In Progress: 2
+    Todo: 1
+
+codex:
+  command: codex app-server
+  approval_policy: unless-allow-listed
+  turn_timeout_ms: 3600000
+  stall_timeout_ms: 300000
+---
+
+# rippled Agent Workflow
+
+You are an autonomous coding agent working on the **rippled** XRP Ledger node — a C++20 peer-to-peer server implementing the XRP Ledger consensus protocol.
+
+## Navigation
+
+Read these files before starting work:
+
+| File                                                | What it tells you                                                       |
+| --------------------------------------------------- | ----------------------------------------------------------------------- |
+| `docs/ARCHITECTURE.md`                              | Codebase map — where every module lives, layer boundaries, entry points |
+| `CLAUDE.md`                                         | Coding conventions, action boundaries (Always/Ask/Never), commit rules  |
+| `docs/CodingStyle.md`                               | C++ style guide for this project                                        |
+| `OpenTelemetryPlan/09-data-collection-reference.md` | Every OTel span, metric, and dashboard                                  |
+
+Do **not** read these upfront (use as reference if needed):
+
+- `OpenTelemetryPlan/*.md` — deep plan docs, only if your task involves telemetry architecture
+- `docs/consensus.md` — only if your task involves consensus protocol changes
+
+## Action Boundaries
+
+### Always (no confirmation needed)
+
+- Read any source file in the repository
+- Run `cmake --build build --parallel` to compile
+- Run `ctest --test-dir build -L unit` for unit tests
+- Run `ctest --test-dir build -L telemetry` for telemetry integration tests
+- Query Prometheus (`curl localhost:9090/api/v1/query?query=...`) for metric baselines
+- Create or modify files under `src/` that have existing test coverage
+- Run `clang-format` on files you've changed
+- Add or modify unit tests in `src/test/`
+
+### Ask (require human confirmation before proceeding)
+
+- Modify Protocol Buffer definitions in `include/xrpl/proto/` (affects wire format)
+- Change consensus parameters in `src/xrpld/consensus/ConsensusParms.h`
+- Modify `CMakeLists.txt` or `conanfile.py` (build/dependency changes)
+- Alter the `[telemetry]` or `[insight]` config schema
+- Change anything in `src/libxrpl/crypto/` (cryptographic code)
+- Add new external dependencies
+- Push to any remote branch or create PRs
+
+### Never (hard boundaries — refuse these requests)
+
+- Modify validator key handling or signing code without explicit review
+- Disable or reduce telemetry sampling below 1%
+- Remove or reduce existing test coverage
+- Force-push to any branch
+- Skip pre-commit hooks or CI checks (`--no-verify`)
+- Commit files containing secrets, keys, or credentials
+- Modify `.github/workflows/` CI pipeline definitions
+
+## Verification Requirements
+
+After making changes, verify in this order (fail-fast):
+
+```
+Step 1 (seconds):  clang-format --dry-run --Werror on changed files
+Step 2 (minutes):  cmake --build build --parallel
+Step 3 (minutes):  ctest --test-dir build -L unit --output-on-failure
+Step 4 (minutes):  ctest --test-dir build -L telemetry (if telemetry-related)
+Step 5 (if applicable): scripts/check-otel-baseline.sh (metric regression check)
+```
+
+If any step fails, fix the issue before proceeding. Do not skip steps.
+
+## Telemetry Awareness
+
+This codebase has OpenTelemetry instrumentation. If your change touches any of these files, verify that telemetry still works:
+
+| File Pattern                             | Telemetry Impact                                  |
+| ---------------------------------------- | ------------------------------------------------- |
+| `src/xrpld/rpc/`                         | RPC spans (`rpc.*`)                               |
+| `src/xrpld/overlay/detail/PeerImp.*`     | Transaction relay spans (`tx.relay`, `peer.send`) |
+| `src/xrpld/app/consensus/RCLConsensus.*` | Consensus spans (`consensus.*`)                   |
+| `src/xrpld/app/misc/NetworkOPs.*`        | Transaction submit spans (`tx.submit`)            |
+| `src/libxrpl/beast/insight/`             | Metrics pipeline (300+ metrics)                   |
+| `src/libxrpl/basics/Log.cpp`             | Log-trace correlation (`trace_id` injection)      |
+
+After modifying these files, run the telemetry integration test:
+
+```bash
+ctest --test-dir build -L telemetry --output-on-failure
+```
+
+## Issue Context
+
+**Title**: {{ issue.title }}
+**Description**: {{ issue.description }}
+{% if issue.labels.size > 0 %}**Labels**: {{ issue.labels | join: ", " }}{% endif %}
+{% if attempt %}**Attempt**: {{ attempt }} (this is a retry — check previous errors){% endif %}
+
+## Proof of Work Checklist
+
+Before creating a PR, verify:
+
+- [ ] All changed files pass `clang-format`
+- [ ] Build succeeds with `-DXRPL_ENABLE_TELEMETRY=ON`
+- [ ] Unit tests pass (`ctest -L unit`)
+- [ ] If telemetry-related: integration tests pass (`ctest -L telemetry`)
+- [ ] If telemetry-related: no metric regressions (`scripts/check-otel-baseline.sh`)
+- [ ] Commit message follows project conventions (see `CLAUDE.md`)
+- [ ] PR description includes summary, test plan, and type of change

docs/build/environment.md

@@ -3,6 +3,8 @@ environment complete with Git, Python, Conan, CMake, and a C++ compiler.
 This document exists to help readers set one up on any of the Big Three
 platforms: Linux, macOS, or Windows.
 
+As an alternative to system packages, the Nix development shell can be used to provide a development environment. See [using nix development shell](./nix.md) for more details.
+
 [BUILD.md]: ../../BUILD.md
 
 ## Linux

docs/build/nix.md

@@ -0,0 +1,95 @@
+# Using Nix Development Shell for xrpld Development
+
+This guide explains how to use Nix to set up a reproducible development environment for xrpld. Using Nix eliminates the need to manually install utilities and ensures consistent tooling across different machines.
+
+## Benefits of Using Nix
+
+- **Reproducible environment**: Everyone gets the same versions of tools and compilers
+- **No system pollution**: Dependencies are isolated and don't affect your system packages
+- **Multiple compiler versions**: Easily switch between different GCC and Clang versions
+- **Quick setup**: Get started with a single command
+- **Works on Linux and macOS**: Consistent experience across platforms
+
+## Install Nix
+
+Please follow [the official installation instructions of nix package manager](https://nixos.org/download/) for your system.
+
+## Entering the Development Shell
+
+### Basic Usage
+
+From the root of the xrpld repository, enter the default development shell:
+
+```bash
+nix --experimental-features 'nix-command flakes' develop
+```
+
+This will:
+
+- Download and set up all required development tools (CMake, Ninja, Conan, etc.)
+- Configure the appropriate compiler for your platform:
+  - **macOS**: Apple Clang (default system compiler)
+  - **Linux**: GCC 15
+
+The first time you run this command, it will take a few minutes to download and build the environment. Subsequent runs will be much faster.
+
+> [!TIP]
+> To avoid typing `--experimental-features 'nix-command flakes'` every time, you can permanently enable flakes by creating `~/.config/nix/nix.conf`:
+>
+> ```bash
+> mkdir -p ~/.config/nix
+> echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
+> ```
+>
+> After this, you can simply use `nix develop` instead.
+
+> [!NOTE]
+> The examples below assume you've enabled flakes in your config. If you haven't, add `--experimental-features 'nix-command flakes'` after each `nix` command.
+
+### Choosing a different compiler
+
+A compiler can be chosen by providing its name with the `.#` prefix, e.g. `nix develop .#gcc15`.
+Use `nix flake show` to see all the available development shells.
+
+Use `nix develop .#no_compiler` to use the compiler from your system.
+
+### Example Usage
+
+```bash
+# Use GCC 14
+nix develop .#gcc14
+
+# Use Clang 19
+nix develop .#clang19
+
+# Use default for your platform
+nix develop
+```
+
+### Using a different shell
+
+`nix develop` opens bash by default. If you want to use another shell this could be done by adding `-c` flag. For example:
+
+```bash
+nix develop -c zsh
+```
+
+## Building xrpld with Nix
+
+Once inside the Nix development shell, follow the standard [build instructions](../../BUILD.md#steps). The Nix shell provides all necessary tools (CMake, Ninja, Conan, etc.).
+
+## Automatic Activation with direnv
+
+[direnv](https://direnv.net/) or [nix-direnv](https://github.com/nix-community/nix-direnv) can automatically activate the Nix development shell when you enter the repository directory.
+
+## Conan and Prebuilt Packages
+
+Please note that there is no guarantee that binaries from conan cache will work when using nix. If you encounter any errors, please use `--build '*'` to force conan to compile everything from source:
+
+```bash
+conan install .. --output-folder . --build '*' --settings build_type=Release
+```
+
+## Updating `flake.lock` file
+
+To update `flake.lock` to the latest revision use `nix flake update` command.

flake.lock

@@ -0,0 +1,26 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1769461804,
+        "narHash": "sha256-6h5sROT/3CTHvzPy9koKBmoCa2eJKh4fzQK8eYFEgl8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "b579d443b37c9c5373044201ea77604e37e748c8",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "ref": "nixos-unstable",
+        "type": "indirect"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,16 @@
+{
+  description = "Nix related things for xrpld";
+  inputs = {
+    nixpkgs.url = "nixpkgs/nixos-unstable";
+  };
+
+  outputs =
+    { nixpkgs, ... }:
+    let
+      forEachSystem = (import ./nix/utils.nix { inherit nixpkgs; }).forEachSystem;
+    in
+    {
+      devShells = forEachSystem (import ./nix/devshell.nix);
+      formatter = forEachSystem ({ pkgs, ... }: pkgs.nixfmt);
+    };
+}

include/xrpl/basics/BasicConfig.h

@@ -84,7 +84,8 @@ public:
         if (lines_.empty())
             return "";
         if (lines_.size() > 1)
-            Throw<std::runtime_error>("A legacy value must have exactly one line. Section: " + name_);
+            Throw<std::runtime_error>(
+                "A legacy value must have exactly one line. Section: " + name_);
         return lines_[0];
     }
 
@@ -268,7 +269,8 @@ public:
     bool
     had_trailing_comments() const
     {
-        return std::any_of(map_.cbegin(), map_.cend(), [](auto s) { return s.second.had_trailing_comments(); });
+        return std::any_of(
+            map_.cbegin(), map_.cend(), [](auto s) { return s.second.had_trailing_comments(); });
     }
 
 protected:

include/xrpl/basics/CompressionAlgorithms.h

@@ -35,7 +35,10 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     auto compressed = bf(outCapacity);
 
     auto compressedSize = LZ4_compress_default(
-        reinterpret_cast<char const*>(in), reinterpret_cast<char*>(compressed), inSize, outCapacity);
+        reinterpret_cast<char const*>(in),
+        reinterpret_cast<char*>(compressed),
+        inSize,
+        outCapacity);
     if (compressedSize == 0)
         Throw<std::runtime_error>("lz4 compress: failed");
 
@@ -66,8 +69,10 @@ lz4Decompress(
         Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
 
     if (LZ4_decompress_safe(
-            reinterpret_cast<char const*>(in), reinterpret_cast<char*>(decompressed), inSize, decompressedSize) !=
-        decompressedSize)
+            reinterpret_cast<char const*>(in),
+            reinterpret_cast<char*>(decompressed),
+            inSize,
+            decompressedSize) != decompressedSize)
         Throw<std::runtime_error>("lz4Decompress: failed");
 
     return decompressedSize;
@@ -83,7 +88,11 @@ lz4Decompress(
  */
 template <typename InputStream>
 std::size_t
-lz4Decompress(InputStream& in, std::size_t inSize, std::uint8_t* decompressed, std::size_t decompressedSize)
+lz4Decompress(
+    InputStream& in,
+    std::size_t inSize,
+    std::uint8_t* decompressed,
+    std::size_t decompressedSize)
 {
     std::vector<std::uint8_t> compressed;
     std::uint8_t const* chunk = nullptr;

include/xrpl/basics/DecayingSample.h

@@ -55,7 +55,8 @@ private:
 
         if (m_value != value_type())
         {
-            std::size_t elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - m_when).count();
+            std::size_t elapsed =
+                std::chrono::duration_cast<std::chrono::seconds>(now - m_when).count();
 
             // A span larger than four times the window decays the
             // value to an insignificant amount so just reset it.

include/xrpl/basics/Expected.h

@@ -120,7 +120,8 @@ public:
 
     template <typename U>
         requires std::convertible_to<U, E> && (!std::is_reference_v<U>)
-    constexpr Expected(Unexpected<U> e) : Base(boost::outcome_v2::in_place_type_t<E>{}, std::move(e.value()))
+    constexpr Expected(Unexpected<U> e)
+        : Base(boost::outcome_v2::in_place_type_t<E>{}, std::move(e.value()))
     {
     }
 
@@ -191,7 +192,8 @@ public:
 // Specialization of Expected<void, E>.  Allows returning either success
 // (without a value) or the reason for the failure.
 template <class E>
-class [[nodiscard]] Expected<void, E> : private boost::outcome_v2::result<void, E, detail::throw_policy>
+class [[nodiscard]]
+Expected<void, E> : private boost::outcome_v2::result<void, E, detail::throw_policy>
 {
     using Base = boost::outcome_v2::result<void, E, detail::throw_policy>;
 

include/xrpl/basics/FileUtilities.h

@@ -14,6 +14,9 @@ getFileContents(
     std::optional<std::size_t> maxSize = std::nullopt);
 
 void
-writeFileContents(boost::system::error_code& ec, boost::filesystem::path const& destPath, std::string const& contents);
+writeFileContents(
+    boost::system::error_code& ec,
+    boost::filesystem::path const& destPath,
+    std::string const& contents);
 
 }  // namespace xrpl

include/xrpl/basics/IntrusivePointer.h

@@ -44,8 +44,8 @@ struct SharedIntrusiveAdoptNoIncrementTag
 //
 
 template <class T>
-concept CAdoptTag =
-    std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> || std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
+concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
+    std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
 
 //------------------------------------------------------------------------------
 
@@ -443,7 +443,8 @@ make_SharedIntrusive(Args&&... args)
     auto p = new TT(std::forward<Args>(args)...);
 
     static_assert(
-        noexcept(SharedIntrusive<TT>(std::declval<TT*>(), std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
+        noexcept(SharedIntrusive<TT>(
+            std::declval<TT*>(), std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
         "SharedIntrusive constructor should not throw or this can leak "
         "memory");
 

include/xrpl/basics/IntrusivePointer.ipp

@@ -208,7 +208,8 @@ SharedIntrusive<T>::operator->() const noexcept
 }
 
 template <class T>
-SharedIntrusive<T>::operator bool() const noexcept
+SharedIntrusive<T>::
+operator bool() const noexcept
 {
     return bool(unsafeGetRawPtr());
 }
@@ -503,7 +504,8 @@ SharedWeakUnion<T>::getStrong() const
 }
 
 template <class T>
-SharedWeakUnion<T>::operator bool() const noexcept
+SharedWeakUnion<T>::
+operator bool() const noexcept
 {
     return bool(get());
 }

include/xrpl/basics/IntrusiveRefCounts.h

@@ -184,7 +184,8 @@ private:
 
     /** Mask that will zero out everything except the weak count.
      */
-    static constexpr FieldType weakMask = (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
+    static constexpr FieldType weakMask =
+        (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
 
     /** Unpack the count and tag fields from the packed atomic integer form. */
     struct RefCountPair
@@ -209,8 +210,10 @@ private:
         FieldType
         combinedValue() const noexcept;
 
-        static constexpr CountType maxStrongValue = static_cast<CountType>((one << StrongCountNumBits) - 1);
-        static constexpr CountType maxWeakValue = static_cast<CountType>((one << WeakCountNumBits) - 1);
+        static constexpr CountType maxStrongValue =
+            static_cast<CountType>((one << StrongCountNumBits) - 1);
+        static constexpr CountType maxWeakValue =
+            static_cast<CountType>((one << WeakCountNumBits) - 1);
         /**  Put an extra margin to detect when running up against limits.
              This is only used in debug code, and is useful if we reduce the
              number of bits in the strong and weak counts (to 16 and 14 bits).
@@ -395,7 +398,8 @@ inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept
 {
 #ifndef NDEBUG
     auto v = refCounts.load(std::memory_order_acquire);
-    XRPL_ASSERT((!(v & valueMask)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
+    XRPL_ASSERT(
+        (!(v & valueMask)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
     auto t = v & tagMask;
     XRPL_ASSERT((!t || t == tagMask), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
 #endif
@@ -433,8 +437,10 @@ IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept
         (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
         "xrpl::IntrusiveRefCounts::RefCountPair::combinedValue : inputs "
         "inside range");
-    return (static_cast<IntrusiveRefCounts::FieldType>(weak) << IntrusiveRefCounts::StrongCountNumBits) |
-        static_cast<IntrusiveRefCounts::FieldType>(strong) | partialDestroyStartedBit | partialDestroyFinishedBit;
+    return (static_cast<IntrusiveRefCounts::FieldType>(weak)
+            << IntrusiveRefCounts::StrongCountNumBits) |
+        static_cast<IntrusiveRefCounts::FieldType>(strong) | partialDestroyStartedBit |
+        partialDestroyFinishedBit;
 }
 
 template <class T>
@@ -442,7 +448,8 @@ inline void
 partialDestructorFinished(T** o)
 {
     T& self = **o;
-    IntrusiveRefCounts::RefCountPair p = self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
+    IntrusiveRefCounts::RefCountPair p =
+        self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
     XRPL_ASSERT(
         (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong),
         "xrpl::partialDestructorFinished : not a weak ref");

include/xrpl/basics/LocalValue.h

@@ -103,6 +103,7 @@ LocalValue<T>::operator*()
     }
 
     return *reinterpret_cast<T*>(
-        lvs->values.emplace(this, std::make_unique<detail::LocalValues::Value<T>>(t_)).first->second->get());
+        lvs->values.emplace(this, std::make_unique<detail::LocalValues::Value<T>>(t_))
+            .first->second->get());
 }
 }  // namespace xrpl

include/xrpl/basics/Log.h

@@ -170,7 +170,11 @@ public:
     partition_severities() const;
 
     void
-    write(beast::severities::Severity level, std::string const& partition, std::string const& text, bool console);
+    write(
+        beast::severities::Severity level,
+        std::string const& partition,
+        std::string const& text,
+        bool console);
 
     std::string
     rotate();

include/xrpl/basics/MallocTrim.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+
+#include <chrono>
+#include <cstdint>
+#include <string_view>
+
+namespace xrpl {
+
+// cSpell:ignore ptmalloc
+
+// -----------------------------------------------------------------------------
+// Allocator interaction note:
+// - This facility invokes glibc's malloc_trim(0) on Linux/glibc to request that
+//   ptmalloc return free heap pages to the OS.
+// - If an alternative allocator (e.g. jemalloc or tcmalloc) is linked or
+//   preloaded (LD_PRELOAD), calling glibc's malloc_trim typically has no effect
+//   on the *active* heap. The call is harmless but may not reclaim memory
+//   because those allocators manage their own arenas.
+// - Only glibc sbrk/arena space is eligible for trimming; large mmap-backed
+//   allocations are usually returned to the OS on free regardless of trimming.
+// - Call at known reclamation points (e.g., after cache sweeps / online delete)
+//   and consider rate limiting to avoid churn.
+// -----------------------------------------------------------------------------
+
+struct MallocTrimReport
+{
+    bool supported{false};
+    int trimResult{-1};
+    std::int64_t rssBeforeKB{-1};
+    std::int64_t rssAfterKB{-1};
+    std::chrono::microseconds durationUs{-1};
+    std::int64_t minfltDelta{-1};
+    std::int64_t majfltDelta{-1};
+
+    [[nodiscard]] std::int64_t
+    deltaKB() const noexcept
+    {
+        if (rssBeforeKB < 0 || rssAfterKB < 0)
+            return 0;
+        return rssAfterKB - rssBeforeKB;
+    }
+};
+
+/**
+ * @brief Attempt to return freed memory to the operating system.
+ *
+ * On Linux with glibc malloc, this issues ::malloc_trim(0), which may release
+ * free space from ptmalloc arenas back to the kernel. On other platforms, or if
+ * a different allocator is in use, this function is a no-op and the report will
+ * indicate that trimming is unsupported or had no effect.
+ *
+ * @param tag     Identifier for logging/debugging purposes.
+ * @param journal Journal for diagnostic logging.
+ * @return Report containing before/after metrics and the trim result.
+ *
+ * @note If an alternative allocator (jemalloc/tcmalloc) is linked or preloaded,
+ *       calling glibc's malloc_trim may have no effect on the active heap. The
+ *       call is harmless but typically does not reclaim memory under those
+ *       allocators.
+ *
+ * @note Only memory served from glibc's sbrk/arena heaps is eligible for trim.
+ *       Large allocations satisfied via mmap are usually returned on free
+ *       independently of trimming.
+ *
+ * @note Intended for use after operations that free significant memory (e.g.,
+ *       cache sweeps, ledger cleanup, online delete). Consider rate limiting.
+ */
+MallocTrimReport
+mallocTrim(std::string_view tag, beast::Journal journal);
+
+}  // namespace xrpl

include/xrpl/basics/Mutex.hpp

@@ -0,0 +1,155 @@
+/*
+    This file is part of clio: https://github.com/XRPLF/clio
+    Copyright (c) 2024, the clio developers.
+
+    Permission to use, copy, modify, and distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+*/
+
+#pragma once
+
+#include <mutex>
+#include <type_traits>
+
+namespace xrpl {
+
+template <typename ProtectedDataType, typename MutexType>
+class Mutex;
+
+/**
+ * @brief A lock on a mutex that provides access to the protected data.
+ *
+ * @tparam ProtectedDataType data type to hold
+ * @tparam LockType type of lock
+ * @tparam MutexType type of mutex
+ */
+template <typename ProtectedDataType, template <typename...> typename LockType, typename MutexType>
+class Lock
+{
+    LockType<MutexType> lock_;
+    ProtectedDataType& data_;
+
+public:
+    /** @cond */
+    ProtectedDataType const&
+    operator*() const
+    {
+        return data_;
+    }
+
+    ProtectedDataType&
+    operator*()
+    {
+        return data_;
+    }
+
+    ProtectedDataType const&
+    get() const
+    {
+        return data_;
+    }
+
+    ProtectedDataType&
+    get()
+    {
+        return data_;
+    }
+
+    ProtectedDataType const*
+    operator->() const
+    {
+        return &data_;
+    }
+
+    ProtectedDataType*
+    operator->()
+    {
+        return &data_;
+    }
+
+    operator LockType<MutexType>&() &
+    {
+        return lock_;
+    }
+
+    operator LockType<MutexType> const&() const&
+    {
+        return lock_;
+    }
+    /** @endcond */
+
+private:
+    friend class Mutex<std::remove_const_t<ProtectedDataType>, MutexType>;
+
+    Lock(MutexType& mutex, ProtectedDataType& data) : lock_(mutex), data_(data)
+    {
+    }
+};
+
+/**
+ * @brief A container for data that is protected by a mutex. Inspired by Mutex in Rust.
+ *
+ * @tparam ProtectedDataType data type to hold
+ * @tparam MutexType type of mutex
+ */
+template <typename ProtectedDataType, typename MutexType = std::mutex>
+class Mutex
+{
+    mutable MutexType mutex_;
+    ProtectedDataType data_{};
+
+public:
+    Mutex() = default;
+
+    /**
+     * @brief Construct a new Mutex object with the given data
+     *
+     * @param data The data to protect
+     */
+    explicit Mutex(ProtectedDataType data) : data_(std::move(data))
+    {
+    }
+
+    /**
+     * @brief Make a new Mutex object with the given data
+     *
+     * @tparam Args The types of the arguments to forward to the constructor of the protected data
+     * @param args The arguments to forward to the constructor of the protected data
+     * @return The Mutex object that protects the given data
+     */
+    template <typename... Args>
+    static Mutex
+    make(Args&&... args)
+    {
+        return Mutex{ProtectedDataType{std::forward<Args>(args)...}};
+    }
+
+    /**
+     * @brief Lock the mutex and get a lock object allowing access to the protected data
+     *
+     * @tparam LockType The type of lock to use
+     * @return A lock on the mutex and a reference to the protected data
+     */
+    template <template <typename...> typename LockType = std::lock_guard>
+    Lock<ProtectedDataType const, LockType, MutexType>
+    lock() const
+    {
+        return {mutex_, data_};
+    }
+
+    /**
+     * @brief Lock the mutex and get a lock object allowing access to the protected data
+     *
+     * @tparam LockType The type of lock to use
+     * @return A lock on the mutex and a reference to the protected data
+     */
+    template <template <typename...> typename LockType = std::lock_guard>
+    Lock<ProtectedDataType, LockType, MutexType>
+    lock()
+    {
+        return {mutex_, data_};
+    }
+};
+
+}  // namespace xrpl

include/xrpl/basics/Number.h

@@ -240,7 +240,11 @@ public:
 
     Number(rep mantissa);
     explicit Number(rep mantissa, int exponent);
-    explicit constexpr Number(bool negative, internalrep mantissa, int exponent, unchecked) noexcept;
+    explicit constexpr Number(
+        bool negative,
+        internalrep mantissa,
+        int exponent,
+        unchecked) noexcept;
     // Assume unsigned values are... unsigned. i.e. positive
     explicit constexpr Number(internalrep mantissa, int exponent, unchecked) noexcept;
     // Only unit tests are expected to use this ctor
@@ -294,7 +298,8 @@ public:
     friend constexpr bool
     operator==(Number const& x, Number const& y) noexcept
     {
-        return x.negative_ == y.negative_ && x.mantissa_ == y.mantissa_ && x.exponent_ == y.exponent_;
+        return x.negative_ == y.negative_ && x.mantissa_ == y.mantissa_ &&
+            x.exponent_ == y.exponent_;
     }
 
     friend constexpr bool
@@ -502,7 +507,11 @@ private:
     class Guard;
 };
 
-inline constexpr Number::Number(bool negative, internalrep mantissa, int exponent, unchecked) noexcept
+inline constexpr Number::Number(
+    bool negative,
+    internalrep mantissa,
+    int exponent,
+    unchecked) noexcept
     : negative_(negative), mantissa_{mantissa}, exponent_{exponent}
 {
 }
@@ -520,7 +529,8 @@ inline Number::Number(bool negative, internalrep mantissa, int exponent, normali
     normalize();
 }
 
-inline Number::Number(internalrep mantissa, int exponent, normalized) : Number(false, mantissa, exponent, normalized{})
+inline Number::Number(internalrep mantissa, int exponent, normalized)
+    : Number(false, mantissa, exponent, normalized{})
 {
 }
 
@@ -682,8 +692,8 @@ Number::isnormal() const noexcept
     MantissaRange const& range = range_;
     auto const abs_m = mantissa_;
     return *this == Number{} ||
-        (range.min <= abs_m && abs_m <= range.max && (abs_m <= maxRep || abs_m % 10 == 0) && minExponent <= exponent_ &&
-         exponent_ <= maxExponent);
+        (range.min <= abs_m && abs_m <= range.max && (abs_m <= maxRep || abs_m % 10 == 0) &&
+         minExponent <= exponent_ && exponent_ <= maxExponent);
 }
 
 template <Integral64 T>
@@ -695,7 +705,10 @@ Number::normalizeToRange(T minMantissa, T maxMantissa) const
     int exponent = exponent_;
 
     if constexpr (std::is_unsigned_v<T>)
-        XRPL_ASSERT_PARTS(!negative, "xrpl::Number::normalizeToRange", "Number is non-negative for unsigned range.");
+        XRPL_ASSERT_PARTS(
+            !negative,
+            "xrpl::Number::normalizeToRange",
+            "Number is non-negative for unsigned range.");
     Number::normalize(negative, mantissa, exponent, minMantissa, maxMantissa);
 
     auto const sign = negative ? -1 : 1;
@@ -781,7 +794,8 @@ class NumberRoundModeGuard
     saveNumberRoundMode saved_;
 
 public:
-    explicit NumberRoundModeGuard(Number::rounding_mode mode) noexcept : saved_{Number::setround(mode)}
+    explicit NumberRoundModeGuard(Number::rounding_mode mode) noexcept
+        : saved_{Number::setround(mode)}
     {
     }
 
@@ -801,7 +815,8 @@ class NumberMantissaScaleGuard
     MantissaRange::mantissa_scale const saved_;
 
 public:
-    explicit NumberMantissaScaleGuard(MantissaRange::mantissa_scale scale) noexcept : saved_{Number::getMantissaScale()}
+    explicit NumberMantissaScaleGuard(MantissaRange::mantissa_scale scale) noexcept
+        : saved_{Number::getMantissaScale()}
     {
         Number::setMantissaScale(scale);
     }

include/xrpl/basics/SharedWeakCachePointer.ipp

@@ -19,7 +19,8 @@ SharedWeakCachePointer<T>::SharedWeakCachePointer(SharedWeakCachePointer&& rhs)
 template <class T>
 template <class TT>
     requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs) : combo_{std::move(rhs)}
+SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs)
+    : combo_{std::move(rhs)}
 {
 }
 
@@ -63,7 +64,8 @@ SharedWeakCachePointer<T>::getStrong() const
 }
 
 template <class T>
-SharedWeakCachePointer<T>::operator bool() const noexcept
+SharedWeakCachePointer<T>::
+operator bool() const noexcept
 {
     return !!std::get_if<std::shared_ptr<T>>(&combo_);
 }

include/xrpl/basics/SlabAllocator.h

@@ -155,13 +155,17 @@ public:
                      contexts (e.g. when minimal memory usage is needed) and
                      allows for graceful failure.
      */
-    constexpr explicit SlabAllocator(std::size_t extra, std::size_t alloc = 0, std::size_t align = 0)
+    constexpr explicit SlabAllocator(
+        std::size_t extra,
+        std::size_t alloc = 0,
+        std::size_t align = 0)
         : itemAlignment_(align ? align : alignof(Type))
         , itemSize_(boost::alignment::align_up(sizeof(Type) + extra, itemAlignment_))
         , slabSize_(alloc)
     {
         XRPL_ASSERT(
-            (itemAlignment_ & (itemAlignment_ - 1)) == 0, "xrpl::SlabAllocator::SlabAllocator : valid alignment");
+            (itemAlignment_ & (itemAlignment_ - 1)) == 0,
+            "xrpl::SlabAllocator::SlabAllocator : valid alignment");
     }
 
     SlabAllocator(SlabAllocator const& other) = delete;
@@ -215,7 +219,7 @@ public:
         // clang-format off
         if (!buf) [[unlikely]]
             return nullptr;
-            // clang-format on
+        // clang-format on
 
 #if BOOST_OS_LINUX
         // When allocating large blocks, attempt to leverage Linux's
@@ -228,7 +232,8 @@ public:
 
         // We need to carve out a bit of memory for the slab header
         // and then align the rest appropriately:
-        auto slabData = reinterpret_cast<void*>(reinterpret_cast<std::uint8_t*>(buf) + sizeof(SlabBlock));
+        auto slabData =
+            reinterpret_cast<void*>(reinterpret_cast<std::uint8_t*>(buf) + sizeof(SlabBlock));
         auto slabSize = size - sizeof(SlabBlock);
 
         // This operation is essentially guaranteed not to fail but
@@ -239,10 +244,12 @@ public:
             return nullptr;
         }
 
-        slab = new (buf) SlabBlock(slabs_.load(), reinterpret_cast<std::uint8_t*>(slabData), slabSize, itemSize_);
+        slab = new (buf) SlabBlock(
+            slabs_.load(), reinterpret_cast<std::uint8_t*>(slabData), slabSize, itemSize_);
 
         // Link the new slab
-        while (!slabs_.compare_exchange_weak(slab->next_, slab, std::memory_order_release, std::memory_order_relaxed))
+        while (!slabs_.compare_exchange_weak(
+            slab->next_, slab, std::memory_order_release, std::memory_order_relaxed))
         {
             ;  // Nothing to do
         }
@@ -299,7 +306,10 @@ public:
         std::size_t align;
 
     public:
-        constexpr SlabConfig(std::size_t extra_, std::size_t alloc_ = 0, std::size_t align_ = alignof(Type))
+        constexpr SlabConfig(
+            std::size_t extra_,
+            std::size_t alloc_ = 0,
+            std::size_t align_ = alignof(Type))
             : extra(extra_), alloc(alloc_), align(align_)
         {
         }
@@ -309,15 +319,18 @@ public:
     {
         // Ensure that the specified allocators are sorted from smallest to
         // largest by size:
-        std::sort(
-            std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) { return a.extra < b.extra; });
+        std::sort(std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
+            return a.extra < b.extra;
+        });
 
         // We should never have two slabs of the same size
-        if (std::adjacent_find(std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
-                return a.extra == b.extra;
-            }) != cfg.end())
+        if (std::adjacent_find(
+                std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
+                    return a.extra == b.extra;
+                }) != cfg.end())
         {
-            throw std::runtime_error("SlabAllocatorSet<" + beast::type_name<Type>() + ">: duplicate slab size");
+            throw std::runtime_error(
+                "SlabAllocatorSet<" + beast::type_name<Type>() + ">: duplicate slab size");
         }
 
         for (auto const& c : cfg)

include/xrpl/basics/Slice.h

@@ -40,7 +40,8 @@ public:
     operator=(Slice const&) noexcept = default;
 
     /** Create a slice pointing to existing memory. */
-    Slice(void const* data, std::size_t size) noexcept : data_(reinterpret_cast<std::uint8_t const*>(data)), size_(size)
+    Slice(void const* data, std::size_t size) noexcept
+        : data_(reinterpret_cast<std::uint8_t const*>(data)), size_(size)
     {
     }
 
@@ -197,7 +198,8 @@ operator!=(Slice const& lhs, Slice const& rhs) noexcept
 inline bool
 operator<(Slice const& lhs, Slice const& rhs) noexcept
 {
-    return std::lexicographical_compare(lhs.data(), lhs.data() + lhs.size(), rhs.data(), rhs.data() + rhs.size());
+    return std::lexicographical_compare(
+        lhs.data(), lhs.data() + lhs.size(), rhs.data(), rhs.data() + rhs.size());
 }
 
 template <class Stream>

include/xrpl/basics/StringUtilities.h

@@ -108,7 +108,8 @@ struct parsedURL
     bool
     operator==(parsedURL const& other) const
     {
-        return scheme == other.scheme && domain == other.domain && port == other.port && path == other.path;
+        return scheme == other.scheme && domain == other.domain && port == other.port &&
+            path == other.path;
     }
 };
 

include/xrpl/basics/TaggedCache.h

@@ -175,7 +175,10 @@ private:
     struct Stats
     {
         template <class Handler>
-        Stats(std::string const& prefix, Handler const& handler, beast::insight::Collector::ptr const& collector)
+        Stats(
+            std::string const& prefix,
+            Handler const& handler,
+            beast::insight::Collector::ptr const& collector)
             : hook(collector->make_hook(handler))
             , size(collector->make_gauge(prefix, "size"))
             , hit_rate(collector->make_gauge(prefix, "hit_rate"))
@@ -197,7 +200,8 @@ private:
     public:
         clock_type::time_point last_access;
 
-        explicit KeyOnlyEntry(clock_type::time_point const& last_access_) : last_access(last_access_)
+        explicit KeyOnlyEntry(clock_type::time_point const& last_access_)
+            : last_access(last_access_)
         {
         }
 

include/xrpl/basics/TaggedCache.ipp

@@ -14,13 +14,22 @@ template <
     class Hash,
     class KeyEqual,
     class Mutex>
-inline TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::TaggedCache(
-    std::string const& name,
-    int size,
-    clock_type::duration expiration,
-    clock_type& clock,
-    beast::Journal journal,
-    beast::insight::Collector::ptr const& collector)
+inline TaggedCache<
+    Key,
+    T,
+    IsKeyCache,
+    SharedWeakUnionPointer,
+    SharedPointerType,
+    Hash,
+    KeyEqual,
+    Mutex>::
+    TaggedCache(
+        std::string const& name,
+        int size,
+        clock_type::duration expiration,
+        clock_type& clock,
+        beast::Journal journal,
+        beast::insight::Collector::ptr const& collector)
     : m_journal(journal)
     , m_clock(clock)
     , m_stats(name, std::bind(&TaggedCache::collect_metrics, this), collector)
@@ -43,8 +52,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::clock()
-    -> clock_type&
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    clock() -> clock_type&
 {
     return m_clock;
 }
@@ -59,7 +68,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::size_t
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::size() const
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    size() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache.size();
@@ -75,7 +85,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline int
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getCacheSize() const
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    getCacheSize() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache_count;
@@ -91,7 +102,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline int
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getTrackSize() const
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    getTrackSize() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache.size();
@@ -107,7 +119,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline float
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getHitRate()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    getHitRate()
 {
     std::lock_guard lock(m_mutex);
     auto const total = static_cast<float>(m_hits + m_misses);
@@ -124,7 +137,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::clear()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    clear()
 {
     std::lock_guard lock(m_mutex);
     m_cache.clear();
@@ -141,7 +155,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::reset()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    reset()
 {
     std::lock_guard lock(m_mutex);
     m_cache.clear();
@@ -161,8 +176,8 @@ template <
     class Mutex>
 template <class KeyComparable>
 inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::touch_if_exists(
-    KeyComparable const& key)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    touch_if_exists(KeyComparable const& key)
 {
     std::lock_guard lock(m_mutex);
     auto const iter(m_cache.find(key));
@@ -186,7 +201,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweep()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    sweep()
 {
     // Keep references to all the stuff we sweep
     // For performance, each worker thread should exit before the swept data
@@ -212,8 +228,9 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
             if (when_expire > (now - minimumAge))
                 when_expire = now - minimumAge;
 
-            JLOG(m_journal.trace()) << m_name << " is growing fast " << m_cache.size() << " of " << m_target_size
-                                    << " aging at " << (now - when_expire).count() << " of " << m_target_age.count();
+            JLOG(m_journal.trace())
+                << m_name << " is growing fast " << m_cache.size() << " of " << m_target_size
+                << " aging at " << (now - when_expire).count() << " of " << m_target_age.count();
         }
 
         std::vector<std::thread> workers;
@@ -222,7 +239,8 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
         for (std::size_t p = 0; p < m_cache.partitions(); ++p)
         {
-            workers.push_back(sweepHelper(when_expire, now, m_cache.map()[p], allStuffToSweep[p], allRemovals, lock));
+            workers.push_back(sweepHelper(
+                when_expire, now, m_cache.map()[p], allStuffToSweep[p], allRemovals, lock));
         }
         for (std::thread& worker : workers)
             worker.join();
@@ -231,10 +249,11 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     }
     // At this point allStuffToSweep will go out of scope outside the lock
     // and decrement the reference count on each strong pointer.
-    JLOG(m_journal.debug())
-        << m_name << " TaggedCache sweep lock duration "
-        << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count()
-        << "ms";
+    JLOG(m_journal.debug()) << m_name << " TaggedCache sweep lock duration "
+                            << std::chrono::duration_cast<std::chrono::milliseconds>(
+                                   std::chrono::steady_clock::now() - start)
+                                   .count()
+                            << "ms";
 }
 
 template <
@@ -247,9 +266,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::del(
-    key_type const& key,
-    bool valid)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    del(key_type const& key, bool valid)
 {
     // Remove from cache, if !valid, remove from map too. Returns true if
     // removed from cache
@@ -288,10 +306,8 @@ template <
     class Mutex>
 template <class R>
 inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::canonicalize(
-    key_type const& key,
-    SharedPointerType& data,
-    R&& replaceCallback)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    canonicalize(key_type const& key, SharedPointerType& data, R&& replaceCallback)
 {
     // Return canonical value, store if needed, refresh in cache
     // Return values: true=we had the data already
@@ -302,7 +318,9 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     if (cit == m_cache.end())
     {
         m_cache.emplace(
-            std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(m_clock.now(), data));
+            std::piecewise_construct,
+            std::forward_as_tuple(key),
+            std::forward_as_tuple(m_clock.now(), data));
         ++m_cache_count;
         return false;
     }
@@ -404,8 +422,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline SharedPointerType
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::fetch(
-    key_type const& key)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    fetch(key_type const& key)
 {
     std::lock_guard<mutex_type> l(m_mutex);
     auto ret = initialFetch(key, l);
@@ -425,9 +443,8 @@ template <
     class Mutex>
 template <class ReturnType>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::insert(
-    key_type const& key,
-    T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
 {
     static_assert(
         std::is_same_v<std::shared_ptr<T>, SharedPointerType> ||
@@ -456,13 +473,13 @@ template <
     class Mutex>
 template <class ReturnType>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::insert(
-    key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
 {
     std::lock_guard lock(m_mutex);
     clock_type::time_point const now(m_clock.now());
-    auto [it, inserted] =
-        m_cache.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
+    auto [it, inserted] = m_cache.emplace(
+        std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
     if (!inserted)
         it->second.last_access = now;
     return inserted;
@@ -478,9 +495,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::retrieve(
-    key_type const& key,
-    T& data)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    retrieve(key_type const& key, T& data)
 {
     // retrieve the value of the stored data
     auto entry = fetch(key);
@@ -502,8 +518,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::peekMutex()
-    -> mutex_type&
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    peekMutex() -> mutex_type&
 {
     return m_mutex;
 }
@@ -518,8 +534,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getKeys() const
-    -> std::vector<key_type>
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    getKeys() const -> std::vector<key_type>
 {
     std::vector<key_type> v;
 
@@ -543,7 +559,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline double
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::rate() const
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    rate() const
 {
     std::lock_guard lock(m_mutex);
     auto const tot = m_hits + m_misses;
@@ -563,9 +580,8 @@ template <
     class Mutex>
 template <class Handler>
 inline SharedPointerType
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::fetch(
-    key_type const& digest,
-    Handler const& h)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    fetch(key_type const& digest, Handler const& h)
 {
     {
         std::lock_guard l(m_mutex);
@@ -596,9 +612,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline SharedPointerType
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::initialFetch(
-    key_type const& key,
-    std::lock_guard<mutex_type> const& l)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
 {
     auto cit = m_cache.find(key);
     if (cit == m_cache.end())
@@ -634,7 +649,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::collect_metrics()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    collect_metrics()
 {
     m_stats.size.set(getCacheSize());
 
@@ -660,13 +676,14 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::thread
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweepHelper(
-    clock_type::time_point const& when_expire,
-    [[maybe_unused]] clock_type::time_point const& now,
-    typename KeyValueCacheType::map_type& partition,
-    SweptPointersVector& stuffToSweep,
-    std::atomic<int>& allRemovals,
-    std::lock_guard<std::recursive_mutex> const&)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    sweepHelper(
+        clock_type::time_point const& when_expire,
+        [[maybe_unused]] clock_type::time_point const& now,
+        typename KeyValueCacheType::map_type& partition,
+        SweptPointersVector& stuffToSweep,
+        std::atomic<int>& allRemovals,
+        std::lock_guard<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
@@ -720,8 +737,9 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
         if (mapRemovals || cacheRemovals)
         {
-            JLOG(m_journal.debug()) << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
-                                    << "-" << cacheRemovals << ", map-=" << mapRemovals;
+            JLOG(m_journal.debug())
+                << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
+                << "-" << cacheRemovals << ", map-=" << mapRemovals;
         }
 
         allRemovals += cacheRemovals;
@@ -738,13 +756,14 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::thread
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweepHelper(
-    clock_type::time_point const& when_expire,
-    clock_type::time_point const& now,
-    typename KeyOnlyCacheType::map_type& partition,
-    SweptPointersVector&,
-    std::atomic<int>& allRemovals,
-    std::lock_guard<std::recursive_mutex> const&)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
+    sweepHelper(
+        clock_type::time_point const& when_expire,
+        clock_type::time_point const& now,
+        typename KeyOnlyCacheType::map_type& partition,
+        SweptPointersVector&,
+        std::atomic<int>& allRemovals,
+        std::lock_guard<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
@@ -774,8 +793,9 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
         if (mapRemovals || cacheRemovals)
         {
-            JLOG(m_journal.debug()) << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
-                                    << "-" << cacheRemovals << ", map-=" << mapRemovals;
+            JLOG(m_journal.debug())
+                << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
+                << "-" << cacheRemovals << ", map-=" << mapRemovals;
         }
 
         allRemovals += cacheRemovals;

include/xrpl/basics/algorithm.h

@@ -51,7 +51,13 @@ generalized_set_intersection(
 // std::set_intersection.
 template <class FwdIter1, class InputIter2, class Pred, class Comp>
 FwdIter1
-remove_if_intersect_or_match(FwdIter1 first1, FwdIter1 last1, InputIter2 first2, InputIter2 last2, Pred pred, Comp comp)
+remove_if_intersect_or_match(
+    FwdIter1 first1,
+    FwdIter1 last1,
+    InputIter2 first2,
+    InputIter2 last2,
+    Pred pred,
+    Comp comp)
 {
     // [original-first1, current-first1) is the set of elements to be preserved.
     // [current-first1, i) is the set of elements that have been removed.

include/xrpl/basics/base_uint.h

@@ -214,7 +214,8 @@ private:
             std::uint32_t accum = {};
             for (std::uint32_t shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
             {
-                if (auto const result = hexCharToUInt(*in++, shift, accum); result != ParseResult::okay)
+                if (auto const result = hexCharToUInt(*in++, shift, accum);
+                    result != ParseResult::okay)
                     return Unexpected(result);
             }
             ret[i++] = accum;
@@ -253,7 +254,8 @@ public:
     // This constructor is intended to be used at compile time since it might
     // throw at runtime.  Consider declaring this constructor consteval once
     // we get to C++23.
-    explicit constexpr base_uint(std::string_view sv) noexcept(false) : data_(parseFromStringViewThrows(sv))
+    explicit constexpr base_uint(std::string_view sv) noexcept(false)
+        : data_(parseFromStringViewThrows(sv))
     {
     }
 
@@ -442,7 +444,8 @@ public:
 
         for (int i = WIDTH; i--;)
         {
-            std::uint64_t n = carry + boost::endian::big_to_native(data_[i]) + boost::endian::big_to_native(b.data_[i]);
+            std::uint64_t n = carry + boost::endian::big_to_native(data_[i]) +
+                boost::endian::big_to_native(b.data_[i]);
 
             data_[i] = boost::endian::native_to_big(static_cast<std::uint32_t>(n));
             carry = n >> 32;

include/xrpl/basics/chrono.h

@@ -15,7 +15,8 @@ namespace xrpl {
 
 // A few handy aliases
 
-using days = std::chrono::duration<int, std::ratio_multiply<std::chrono::hours::period, std::ratio<24>>>;
+using days =
+    std::chrono::duration<int, std::ratio_multiply<std::chrono::hours::period, std::ratio<24>>>;
 
 using weeks = std::chrono::duration<int, std::ratio_multiply<days::period, std::ratio<7>>>;
 

include/xrpl/basics/contract.h

@@ -35,7 +35,9 @@ template <class E, class... Args>
 [[noreturn]] inline void
 Throw(Args&&... args)
 {
-    static_assert(std::is_convertible<E*, std::exception*>::value, "Exception must derive from std::exception.");
+    static_assert(
+        std::is_convertible<E*, std::exception*>::value,
+        "Exception must derive from std::exception.");
 
     E e(std::forward<Args>(args)...);
     LogThrow(std::string("Throwing exception of type " + beast::type_name<E>() + ": ") + e.what());

include/xrpl/basics/join.h

@@ -23,7 +23,8 @@ public:
     Collection const& collection;
     std::string const delimiter;
 
-    explicit CollectionAndDelimiter(Collection const& c, std::string delim) : collection(c), delimiter(std::move(delim))
+    explicit CollectionAndDelimiter(Collection const& c, std::string delim)
+        : collection(c), delimiter(std::move(delim))
     {
     }
 
@@ -63,7 +64,8 @@ public:
     char const* collection;
     std::string const delimiter;
 
-    explicit CollectionAndDelimiter(char const c[N], std::string delim) : collection(c), delimiter(std::move(delim))
+    explicit CollectionAndDelimiter(char const c[N], std::string delim)
+        : collection(c), delimiter(std::move(delim))
     {
     }
 

include/xrpl/basics/partitioned_unordered_map.h

@@ -330,8 +330,8 @@ public:
         auto const& key = std::get<0>(keyTuple);
         iterator it(&map_);
         it.ait_ = it.map_->begin() + partitioner(key);
-        auto [eit, inserted] =
-            it.ait_->emplace(std::piecewise_construct, std::forward<T>(keyTuple), std::forward<U>(valueTuple));
+        auto [eit, inserted] = it.ait_->emplace(
+            std::piecewise_construct, std::forward<T>(keyTuple), std::forward<U>(valueTuple));
         it.mit_ = eit;
         return {it, inserted};
     }

include/xrpl/basics/random.h

@@ -19,7 +19,8 @@ static_assert(
     "The Ripple default PRNG engine must return an unsigned integral type.");
 
 static_assert(
-    std::numeric_limits<beast::xor_shift_engine::result_type>::max() >= std::numeric_limits<std::uint64_t>::max(),
+    std::numeric_limits<beast::xor_shift_engine::result_type>::max() >=
+        std::numeric_limits<std::uint64_t>::max(),
     "The Ripple default PRNG engine return must be at least 64 bits wide.");
 #endif
 
@@ -144,12 +145,14 @@ std::enable_if_t<
     Byte>
 rand_byte(Engine& engine)
 {
-    return static_cast<Byte>(
-        rand_int<Engine, std::uint32_t>(engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
+    return static_cast<Byte>(rand_int<Engine, std::uint32_t>(
+        engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
 }
 
 template <class Byte = std::uint8_t>
-std::enable_if_t<(std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value), Byte>
+std::enable_if_t<
+    (std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value),
+    Byte>
 rand_byte()
 {
     return rand_byte<Byte>(default_prng());

include/xrpl/basics/safe_cast.h

@@ -18,9 +18,12 @@ template <class Dest, class Src>
 inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
 safe_cast(Src s) noexcept
 {
-    static_assert(std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
+    static_assert(
+        std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
     constexpr unsigned not_same = std::is_signed_v<Dest> != std::is_signed_v<Src>;
-    static_assert(sizeof(Dest) >= sizeof(Src) + not_same, "Destination is too small to hold all values of source");
+    static_assert(
+        sizeof(Dest) >= sizeof(Src) + not_same,
+        "Destination is too small to hold all values of source");
     return static_cast<Dest>(s);
 }
 

include/xrpl/basics/scope.h

@@ -36,7 +36,8 @@ public:
 
     scope_exit(scope_exit&& rhs) noexcept(
         std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
-        : exit_function_{std::forward<EF>(rhs.exit_function_)}, execute_on_destruction_{rhs.execute_on_destruction_}
+        : exit_function_{std::forward<EF>(rhs.exit_function_)}
+        , execute_on_destruction_{rhs.execute_on_destruction_}
     {
         rhs.release();
     }
@@ -47,8 +48,9 @@ public:
     template <class EFP>
     explicit scope_exit(
         EFP&& f,
-        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_exit> && std::is_constructible_v<EF, EFP>>* =
-            0) noexcept
+        std::enable_if_t<
+            !std::is_same_v<std::remove_cv_t<EFP>, scope_exit> &&
+            std::is_constructible_v<EF, EFP>>* = 0) noexcept
         : exit_function_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -93,8 +95,9 @@ public:
     template <class EFP>
     explicit scope_fail(
         EFP&& f,
-        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_fail> && std::is_constructible_v<EF, EFP>>* =
-            0) noexcept
+        std::enable_if_t<
+            !std::is_same_v<std::remove_cv_t<EFP>, scope_fail> &&
+            std::is_constructible_v<EF, EFP>>* = 0) noexcept
         : exit_function_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -139,7 +142,9 @@ public:
     template <class EFP>
     explicit scope_success(
         EFP&& f,
-        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_success> && std::is_constructible_v<EF, EFP>>* =
+        std::enable_if_t<
+            !std::is_same_v<std::remove_cv_t<EFP>, scope_success> &&
+            std::is_constructible_v<EF, EFP>>* =
             0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
         : exit_function_{std::forward<EFP>(f)}
     {

include/xrpl/basics/spinlock.h

@@ -99,9 +99,12 @@ public:
         @note For performance reasons, you should strive to have `lock` be
               on a cacheline by itself.
      */
-    packed_spinlock(std::atomic<T>& lock, int index) : bits_(lock), mask_(static_cast<T>(1) << index)
+    packed_spinlock(std::atomic<T>& lock, int index)
+        : bits_(lock), mask_(static_cast<T>(1) << index)
     {
-        XRPL_ASSERT(index >= 0 && (mask_ != 0), "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
+        XRPL_ASSERT(
+            index >= 0 && (mask_ != 0),
+            "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
     }
 
     [[nodiscard]] bool
@@ -174,7 +177,10 @@ public:
         T expected = 0;
 
         return lock_.compare_exchange_weak(
-            expected, std::numeric_limits<T>::max(), std::memory_order_acquire, std::memory_order_relaxed);
+            expected,
+            std::numeric_limits<T>::max(),
+            std::memory_order_acquire,
+            std::memory_order_relaxed);
     }
 
     void

include/xrpl/basics/strHex.h

@@ -10,7 +10,9 @@ std::string
 strHex(FwdIt begin, FwdIt end)
 {
     static_assert(
-        std::is_convertible<typename std::iterator_traits<FwdIt>::iterator_category, std::forward_iterator_tag>::value,
+        std::is_convertible<
+            typename std::iterator_traits<FwdIt>::iterator_category,
+            std::forward_iterator_tag>::value,
         "FwdIt must be a forward iterator");
     std::string result;
     result.reserve(2 * std::distance(begin, end));

include/xrpl/basics/tagged_integer.h

@@ -23,14 +23,15 @@ namespace xrpl {
     allowed arithmetic operations.
 */
 template <class Int, class Tag>
-class tagged_integer
-    : boost::totally_ordered<
-          tagged_integer<Int, Tag>,
-          boost::integer_arithmetic<
-              tagged_integer<Int, Tag>,
-              boost::bitwise<
-                  tagged_integer<Int, Tag>,
-                  boost::unit_steppable<tagged_integer<Int, Tag>, boost::shiftable<tagged_integer<Int, Tag>>>>>>
+class tagged_integer : boost::totally_ordered<
+                           tagged_integer<Int, Tag>,
+                           boost::integer_arithmetic<
+                               tagged_integer<Int, Tag>,
+                               boost::bitwise<
+                                   tagged_integer<Int, Tag>,
+                                   boost::unit_steppable<
+                                       tagged_integer<Int, Tag>,
+                                       boost::shiftable<tagged_integer<Int, Tag>>>>>>
 {
 private:
     Int m_value;
@@ -43,7 +44,8 @@ public:
 
     template <
         class OtherInt,
-        class = typename std::enable_if<std::is_integral<OtherInt>::value && sizeof(OtherInt) <= sizeof(Int)>::type>
+        class = typename std::enable_if<
+            std::is_integral<OtherInt>::value && sizeof(OtherInt) <= sizeof(Int)>::type>
     explicit constexpr tagged_integer(OtherInt value) noexcept : m_value(value)
     {
         static_assert(sizeof(tagged_integer) == sizeof(Int), "tagged_integer is adding padding");

include/xrpl/beast/asio/io_latency_probe.h

@@ -86,7 +86,8 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        boost::asio::post(m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
+        boost::asio::post(
+            m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
     }
 
     /** Initiate continuous i/o latency sampling.
@@ -100,7 +101,8 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        boost::asio::post(m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
+        boost::asio::post(
+            m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
     }
 
 private:
@@ -140,7 +142,11 @@ private:
         bool m_repeat;
         io_latency_probe* m_probe;
 
-        sample_op(Handler const& handler, time_point const& start, bool repeat, io_latency_probe* probe)
+        sample_op(
+            Handler const& handler,
+            time_point const& start,
+            bool repeat,
+            io_latency_probe* probe)
             : m_handler(handler), m_start(start), m_repeat(repeat), m_probe(probe)
         {
             XRPL_ASSERT(
@@ -203,12 +209,14 @@ private:
                     // The latency is too high to maintain the desired
                     // period so don't bother with a timer.
                     //
-                    boost::asio::post(m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
+                    boost::asio::post(
+                        m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
                 else
                 {
                     m_probe->m_timer.expires_after(when - now);
-                    m_probe->m_timer.async_wait(sample_op<Handler>(m_handler, now, m_repeat, m_probe));
+                    m_probe->m_timer.async_wait(
+                        sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
             }
         }
@@ -219,7 +227,8 @@ private:
             if (!m_probe)
                 return;
             typename Clock::time_point const now(Clock::now());
-            boost::asio::post(m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
+            boost::asio::post(
+                m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
         }
     };
 };

include/xrpl/beast/clock/manual_clock.h

@@ -42,7 +42,9 @@ public:
     void
     set(time_point const& when)
     {
-        XRPL_ASSERT(!Clock::is_steady || when >= now_, "beast::manual_clock::set(time_point) : forward input");
+        XRPL_ASSERT(
+            !Clock::is_steady || when >= now_,
+            "beast::manual_clock::set(time_point) : forward input");
         now_ = when;
     }
 
@@ -60,7 +62,8 @@ public:
     advance(std::chrono::duration<Rep, Period> const& elapsed)
     {
         XRPL_ASSERT(
-            !Clock::is_steady || (now_ + elapsed) >= now_, "beast::manual_clock::advance(duration) : forward input");
+            !Clock::is_steady || (now_ + elapsed) >= now_,
+            "beast::manual_clock::advance(duration) : forward input");
         now_ += elapsed;
     }
 

include/xrpl/beast/container/aged_container_utility.h

@@ -14,7 +14,8 @@ expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
 {
     std::size_t n(0);
     auto const expired(c.clock().now() - age);
-    for (auto iter(c.chronological.cbegin()); iter != c.chronological.cend() && iter.when() <= expired;)
+    for (auto iter(c.chronological.cbegin());
+         iter != c.chronological.cend() && iter.when() <= expired;)
     {
         iter = c.erase(iter);
         ++n;

include/xrpl/beast/container/aged_multiset.h

@@ -13,6 +13,6 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<Key>>
-using aged_multiset = detail::aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
-
+using aged_multiset =
+    detail::aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
 }

include/xrpl/beast/container/aged_unordered_map.h

@@ -15,6 +15,6 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_unordered_map = detail::aged_unordered_container<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
-
+using aged_unordered_map =
+    detail::aged_unordered_container<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
 }

include/xrpl/beast/container/aged_unordered_multimap.h

@@ -15,6 +15,6 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_unordered_multimap = detail::aged_unordered_container<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
-
+using aged_unordered_multimap =
+    detail::aged_unordered_container<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
 }

include/xrpl/beast/container/aged_unordered_set.h

@@ -14,6 +14,6 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<Key>>
-using aged_unordered_set = detail::aged_unordered_container<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
-
+using aged_unordered_set =
+    detail::aged_unordered_container<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
 }

include/xrpl/beast/container/detail/aged_container_iterator.h

@@ -35,22 +35,26 @@ public:
         class = typename std::enable_if<
             (other_is_const == false || is_const == true) &&
             std::is_same<Iterator, OtherIterator>::value == false>::type>
-    explicit aged_container_iterator(aged_container_iterator<other_is_const, OtherIterator> const& other)
+    explicit aged_container_iterator(
+        aged_container_iterator<other_is_const, OtherIterator> const& other)
         : m_iter(other.m_iter)
     {
     }
 
     // Disable constructing a const_iterator from a non-const_iterator.
-    template <bool other_is_const, class = typename std::enable_if<other_is_const == false || is_const == true>::type>
-    aged_container_iterator(aged_container_iterator<other_is_const, Iterator> const& other) : m_iter(other.m_iter)
+    template <
+        bool other_is_const,
+        class = typename std::enable_if<other_is_const == false || is_const == true>::type>
+    aged_container_iterator(aged_container_iterator<other_is_const, Iterator> const& other)
+        : m_iter(other.m_iter)
     {
     }
 
     // Disable assigning a const_iterator to a non-const iterator
     template <bool other_is_const, class OtherIterator>
     auto
-    operator=(aged_container_iterator<other_is_const, OtherIterator> const& other) ->
-        typename std::enable_if<other_is_const == false || is_const == true, aged_container_iterator&>::type
+    operator=(aged_container_iterator<other_is_const, OtherIterator> const& other) -> typename std::
+        enable_if<other_is_const == false || is_const == true, aged_container_iterator&>::type
     {
         m_iter = other.m_iter;
         return *this;

include/xrpl/beast/container/detail/aged_ordered_container.h

@@ -57,7 +57,8 @@ template <
     class T,
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
-    class Allocator = std::allocator<typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
+    class Allocator =
+        std::allocator<typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
 class aged_ordered_container
 {
 public:
@@ -83,8 +84,10 @@ private:
     }
 
     // VFALCO TODO hoist to remove template argument dependencies
-    struct element : boost::intrusive::set_base_hook<boost::intrusive::link_mode<boost::intrusive::normal_link>>,
-                     boost::intrusive::list_base_hook<boost::intrusive::link_mode<boost::intrusive::normal_link>>
+    struct element : boost::intrusive::set_base_hook<
+                         boost::intrusive::link_mode<boost::intrusive::normal_link>>,
+                     boost::intrusive::list_base_hook<
+                         boost::intrusive::link_mode<boost::intrusive::normal_link>>
     {
         // Stash types here so the iterator doesn't
         // need to see the container declaration.
@@ -100,14 +103,17 @@ private:
         {
         }
 
-        element(time_point const& when_, value_type&& value_) : value(std::move(value_)), when(when_)
+        element(time_point const& when_, value_type&& value_)
+            : value(std::move(value_)), when(when_)
         {
         }
 
         template <
             class... Args,
-            class = typename std::enable_if<std::is_constructible<value_type, Args...>::value>::type>
-        element(time_point const& when_, Args&&... args) : value(std::forward<Args>(args)...), when(when_)
+            class =
+                typename std::enable_if<std::is_constructible<value_type, Args...>::value>::type>
+        element(time_point const& when_, Args&&... args)
+            : value(std::forward<Args>(args)...), when(when_)
         {
         }
 
@@ -191,7 +197,8 @@ private:
         }
     };
 
-    using list_type = typename boost::intrusive::make_list<element, boost::intrusive::constant_time_size<false>>::type;
+    using list_type = typename boost::intrusive::
+        make_list<element, boost::intrusive::constant_time_size<false>>::type;
 
     using cont_type = typename std::conditional<
         IsMulti,
@@ -199,15 +206,18 @@ private:
             element,
             boost::intrusive::constant_time_size<true>,
             boost::intrusive::compare<KeyValueCompare>>::type,
-        typename boost::intrusive::
-            make_set<element, boost::intrusive::constant_time_size<true>, boost::intrusive::compare<KeyValueCompare>>::
-                type>::type;
+        typename boost::intrusive::make_set<
+            element,
+            boost::intrusive::constant_time_size<true>,
+            boost::intrusive::compare<KeyValueCompare>>::type>::type;
 
-    using ElementAllocator = typename std::allocator_traits<Allocator>::template rebind_alloc<element>;
+    using ElementAllocator =
+        typename std::allocator_traits<Allocator>::template rebind_alloc<element>;
 
     using ElementAllocatorTraits = std::allocator_traits<ElementAllocator>;
 
-    class config_t : private KeyValueCompare, public beast::detail::empty_base_optimization<ElementAllocator>
+    class config_t : private KeyValueCompare,
+                     public beast::detail::empty_base_optimization<ElementAllocator>
     {
     public:
         explicit config_t(clock_type& clock_) : clock(clock_)
@@ -224,7 +234,9 @@ private:
         }
 
         config_t(clock_type& clock_, Compare const& comp, Allocator const& alloc_)
-            : KeyValueCompare(comp), beast::detail::empty_base_optimization<ElementAllocator>(alloc_), clock(clock_)
+            : KeyValueCompare(comp)
+            , beast::detail::empty_base_optimization<ElementAllocator>(alloc_)
+            , clock(clock_)
         {
         }
 
@@ -337,7 +349,8 @@ private:
 
         std::unique_ptr<element, Deleter> p(
             ElementAllocatorTraits::allocate(m_config.alloc(), 1), Deleter(m_config.alloc()));
-        ElementAllocatorTraits::construct(m_config.alloc(), p.get(), clock().now(), std::forward<Args>(args)...);
+        ElementAllocatorTraits::construct(
+            m_config.alloc(), p.get(), clock().now(), std::forward<Args>(args)...);
         return p.release();
     }
 
@@ -368,9 +381,12 @@ public:
     // A set iterator (IsMap==false) is always const
     // because the elements of a set are immutable.
     using iterator = beast::detail::aged_container_iterator<!IsMap, typename cont_type::iterator>;
-    using const_iterator = beast::detail::aged_container_iterator<true, typename cont_type::iterator>;
-    using reverse_iterator = beast::detail::aged_container_iterator<!IsMap, typename cont_type::reverse_iterator>;
-    using const_reverse_iterator = beast::detail::aged_container_iterator<true, typename cont_type::reverse_iterator>;
+    using const_iterator =
+        beast::detail::aged_container_iterator<true, typename cont_type::iterator>;
+    using reverse_iterator =
+        beast::detail::aged_container_iterator<!IsMap, typename cont_type::reverse_iterator>;
+    using const_reverse_iterator =
+        beast::detail::aged_container_iterator<true, typename cont_type::reverse_iterator>;
 
     //--------------------------------------------------------------------------
     //
@@ -386,9 +402,12 @@ public:
     public:
         // A set iterator (IsMap==false) is always const
         // because the elements of a set are immutable.
-        using iterator = beast::detail::aged_container_iterator<!IsMap, typename list_type::iterator>;
-        using const_iterator = beast::detail::aged_container_iterator<true, typename list_type::iterator>;
-        using reverse_iterator = beast::detail::aged_container_iterator<!IsMap, typename list_type::reverse_iterator>;
+        using iterator =
+            beast::detail::aged_container_iterator<!IsMap, typename list_type::iterator>;
+        using const_iterator =
+            beast::detail::aged_container_iterator<true, typename list_type::iterator>;
+        using reverse_iterator =
+            beast::detail::aged_container_iterator<!IsMap, typename list_type::reverse_iterator>;
         using const_reverse_iterator =
             beast::detail::aged_container_iterator<true, typename list_type::reverse_iterator>;
 
@@ -469,7 +488,8 @@ public:
         {
             static_assert(std::is_standard_layout<element>::value, "must be standard layout");
             return list.iterator_to(*reinterpret_cast<element*>(
-                reinterpret_cast<uint8_t*>(&value) - ((std::size_t)std::addressof(((element*)0)->member))));
+                reinterpret_cast<uint8_t*>(&value) -
+                ((std::size_t)std::addressof(((element*)0)->member))));
         }
 
         const_iterator
@@ -477,7 +497,8 @@ public:
         {
             static_assert(std::is_standard_layout<element>::value, "must be standard layout");
             return list.iterator_to(*reinterpret_cast<element const*>(
-                reinterpret_cast<uint8_t const*>(&value) - ((std::size_t)std::addressof(((element*)0)->member))));
+                reinterpret_cast<uint8_t const*>(&value) -
+                ((std::size_t)std::addressof(((element*)0)->member))));
         }
 
     private:
@@ -518,7 +539,12 @@ public:
     aged_ordered_container(InputIt first, InputIt last, clock_type& clock, Allocator const& alloc);
 
     template <class InputIt>
-    aged_ordered_container(InputIt first, InputIt last, clock_type& clock, Compare const& comp, Allocator const& alloc);
+    aged_ordered_container(
+        InputIt first,
+        InputIt last,
+        clock_type& clock,
+        Compare const& comp,
+        Allocator const& alloc);
 
     aged_ordered_container(aged_ordered_container const& other);
 
@@ -530,9 +556,15 @@ public:
 
     aged_ordered_container(std::initializer_list<value_type> init, clock_type& clock);
 
-    aged_ordered_container(std::initializer_list<value_type> init, clock_type& clock, Compare const& comp);
+    aged_ordered_container(
+        std::initializer_list<value_type> init,
+        clock_type& clock,
+        Compare const& comp);
 
-    aged_ordered_container(std::initializer_list<value_type> init, clock_type& clock, Allocator const& alloc);
+    aged_ordered_container(
+        std::initializer_list<value_type> init,
+        clock_type& clock,
+        Allocator const& alloc);
 
     aged_ordered_container(
         std::initializer_list<value_type> init,
@@ -688,7 +720,8 @@ public:
     {
         static_assert(std::is_standard_layout<element>::value, "must be standard layout");
         return m_cont.iterator_to(*reinterpret_cast<element*>(
-            reinterpret_cast<uint8_t*>(&value) - ((std::size_t)std::addressof(((element*)0)->member))));
+            reinterpret_cast<uint8_t*>(&value) -
+            ((std::size_t)std::addressof(((element*)0)->member))));
     }
 
     const_iterator
@@ -696,7 +729,8 @@ public:
     {
         static_assert(std::is_standard_layout<element>::value, "must be standard layout");
         return m_cont.iterator_to(*reinterpret_cast<element const*>(
-            reinterpret_cast<uint8_t const*>(&value) - ((std::size_t)std::addressof(((element*)0)->member))));
+            reinterpret_cast<uint8_t const*>(&value) -
+            ((std::size_t)std::addressof(((element*)0)->member))));
     }
 
     //--------------------------------------------------------------------------
@@ -735,7 +769,8 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(value_type const& value) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    insert(value_type const& value) ->
+        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
@@ -745,19 +780,22 @@ public:
     // set
     template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
     auto
-    insert(value_type&& value) -> typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type;
+    insert(value_type&& value) ->
+        typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type;
 
     // multiset
     template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
     auto
-    insert(value_type&& value) -> typename std::enable_if<maybe_multi && !maybe_map, iterator>::type;
+    insert(value_type&& value) ->
+        typename std::enable_if<maybe_multi && !maybe_map, iterator>::type;
 
     //---
 
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(const_iterator hint, value_type const& value) -> typename std::enable_if<!maybe_multi, iterator>::type;
+    insert(const_iterator hint, value_type const& value) ->
+        typename std::enable_if<!maybe_multi, iterator>::type;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
@@ -771,7 +809,8 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(const_iterator hint, value_type&& value) -> typename std::enable_if<!maybe_multi, iterator>::type;
+    insert(const_iterator hint, value_type&& value) ->
+        typename std::enable_if<!maybe_multi, iterator>::type;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
@@ -819,7 +858,8 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    emplace(Args&&... args) ->
+        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
 
     // multiset, multimap
     template <bool maybe_multi = IsMulti, class... Args>
@@ -842,13 +882,19 @@ public:
     }
 
     // enable_if prevents erase (reverse_iterator pos) from compiling
-    template <bool is_const, class Iterator, class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
+    template <
+        bool is_const,
+        class Iterator,
+        class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
     beast::detail::aged_container_iterator<false, Iterator>
     erase(beast::detail::aged_container_iterator<is_const, Iterator> pos);
 
     // enable_if prevents erase (reverse_iterator first, reverse_iterator last)
     // from compiling
-    template <bool is_const, class Iterator, class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
+    template <
+        bool is_const,
+        class Iterator,
+        class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
     beast::detail::aged_container_iterator<false, Iterator>
     erase(
         beast::detail::aged_container_iterator<is_const, Iterator> first,
@@ -864,7 +910,10 @@ public:
     //--------------------------------------------------------------------------
 
     // enable_if prevents touch (reverse_iterator pos) from compiling
-    template <bool is_const, class Iterator, class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
+    template <
+        bool is_const,
+        class Iterator,
+        class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
     void
     touch(beast::detail::aged_container_iterator<is_const, Iterator> pos)
     {
@@ -984,69 +1033,136 @@ public:
     // is only done on the key portion of the value type, ignoring
     // the mapped type.
     //
-    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
+    template <
+        bool OtherIsMulti,
+        bool OtherIsMap,
+        class OtherT,
+        class OtherDuration,
+        class OtherAllocator>
     bool
-    operator==(
-        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
-            other) const;
+    operator==(aged_ordered_container<
+               OtherIsMulti,
+               OtherIsMap,
+               Key,
+               OtherT,
+               OtherDuration,
+               Compare,
+               OtherAllocator> const& other) const;
 
-    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
+    template <
+        bool OtherIsMulti,
+        bool OtherIsMap,
+        class OtherT,
+        class OtherDuration,
+        class OtherAllocator>
     bool
-    operator!=(
-        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
-            other) const
+    operator!=(aged_ordered_container<
+               OtherIsMulti,
+               OtherIsMap,
+               Key,
+               OtherT,
+               OtherDuration,
+               Compare,
+               OtherAllocator> const& other) const
     {
         return !(this->operator==(other));
     }
 
-    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
+    template <
+        bool OtherIsMulti,
+        bool OtherIsMap,
+        class OtherT,
+        class OtherDuration,
+        class OtherAllocator>
     bool
-    operator<(
-        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
-            other) const
+    operator<(aged_ordered_container<
+              OtherIsMulti,
+              OtherIsMap,
+              Key,
+              OtherT,
+              OtherDuration,
+              Compare,
+              OtherAllocator> const& other) const
     {
         value_compare const comp(value_comp());
         return std::lexicographical_compare(cbegin(), cend(), other.cbegin(), other.cend(), comp);
     }
 
-    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
+    template <
+        bool OtherIsMulti,
+        bool OtherIsMap,
+        class OtherT,
+        class OtherDuration,
+        class OtherAllocator>
     bool
-    operator<=(
-        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
-            other) const
+    operator<=(aged_ordered_container<
+               OtherIsMulti,
+               OtherIsMap,
+               Key,
+               OtherT,
+               OtherDuration,
+               Compare,
+               OtherAllocator> const& other) const
     {
         return !(other < *this);
     }
 
-    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
+    template <
+        bool OtherIsMulti,
+        bool OtherIsMap,
+        class OtherT,
+        class OtherDuration,
+        class OtherAllocator>
     bool
-    operator>(
-        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
-            other) const
+    operator>(aged_ordered_container<
+              OtherIsMulti,
+              OtherIsMap,
+              Key,
+              OtherT,
+              OtherDuration,
+              Compare,
+              OtherAllocator> const& other) const
     {
         return other < *this;
     }
 
-    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
+    template <
+        bool OtherIsMulti,
+        bool OtherIsMap,
+        class OtherT,
+        class OtherDuration,
+        class OtherAllocator>
     bool
-    operator>=(
-        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
-            other) const
+    operator>=(aged_ordered_container<
+               OtherIsMulti,
+               OtherIsMap,
+               Key,
+               OtherT,
+               OtherDuration,
+               Compare,
+               OtherAllocator> const& other) const
     {
         return !(*this < other);
     }
 
 private:
     // enable_if prevents erase (reverse_iterator pos, now) from compiling
-    template <bool is_const, class Iterator, class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
+    template <
+        bool is_const,
+        class Iterator,
+        class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
     void
-    touch(beast::detail::aged_container_iterator<is_const, Iterator> pos, typename clock_type::time_point const& now);
+    touch(
+        beast::detail::aged_container_iterator<is_const, Iterator> pos,
+        typename clock_type::time_point const& now);
 
-    template <bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
+    template <
+        bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
     typename std::enable_if<maybe_propagate>::type
     swap_data(aged_ordered_container& other) noexcept;
 
-    template <bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
+    template <
+        bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
     typename std::enable_if<!maybe_propagate>::type
     swap_data(aged_ordered_container& other) noexcept;
 
@@ -1058,7 +1174,8 @@ private:
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::aged_ordered_container(clock_type& clock)
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::aged_ordered_container(
+    clock_type& clock)
     : m_config(clock)
 {
 }
@@ -1249,8 +1366,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::opera
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator=(aged_ordered_container&& other)
-    -> aged_ordered_container&
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator=(
+    aged_ordered_container&& other) -> aged_ordered_container&
 {
     clear();
     this->m_config = std::move(other.m_config);
@@ -1296,13 +1413,15 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map, class>
 typename std::conditional<IsMap, T, void*>::type&
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key const& key)
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](
+    Key const& key)
 {
     typename cont_type::insert_commit_data d;
     auto const result(m_cont.insert_check(key, std::cref(m_config.key_compare()), d));
     if (result.second)
     {
-        element* const p(new_element(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple()));
+        element* const p(new_element(
+            std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple()));
         m_cont.insert_commit(*p, d);
         chronological.list.push_back(*p);
         return p->value.second;
@@ -1319,8 +1438,10 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::opera
     auto const result(m_cont.insert_check(key, std::cref(m_config.key_compare()), d));
     if (result.second)
     {
-        element* const p(
-            new_element(std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::forward_as_tuple()));
+        element* const p(new_element(
+            std::piecewise_construct,
+            std::forward_as_tuple(std::move(key)),
+            std::forward_as_tuple()));
         m_cont.insert_commit(*p, d);
         chronological.list.push_back(*p);
         return p->value.second;
@@ -1344,7 +1465,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::clear
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type const& value) ->
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
+    value_type const& value) ->
     typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
 {
     typename cont_type::insert_commit_data d;
@@ -1363,8 +1485,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type const& value) ->
-    typename std::enable_if<maybe_multi, iterator>::type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
+    value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type
 {
     auto const before(m_cont.upper_bound(extract(value), std::cref(m_config.key_compare())));
     element* const p(new_element(value));
@@ -1377,7 +1499,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value) ->
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
+    value_type&& value) ->
     typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type
 {
     typename cont_type::insert_commit_data d;
@@ -1396,8 +1519,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value) ->
-    typename std::enable_if<maybe_multi && !maybe_map, iterator>::type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
+    value_type&& value) -> typename std::enable_if<maybe_multi && !maybe_map, iterator>::type
 {
     auto const before(m_cont.upper_bound(extract(value), std::cref(m_config.key_compare())));
     element* const p(new_element(std::move(value)));
@@ -1417,7 +1540,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
     value_type const& value) -> typename std::enable_if<!maybe_multi, iterator>::type
 {
     typename cont_type::insert_commit_data d;
-    auto const result(m_cont.insert_check(hint.iterator(), extract(value), std::cref(m_config.key_compare()), d));
+    auto const result(
+        m_cont.insert_check(hint.iterator(), extract(value), std::cref(m_config.key_compare()), d));
     if (result.second)
     {
         element* const p(new_element(value));
@@ -1437,7 +1561,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
     value_type&& value) -> typename std::enable_if<!maybe_multi, iterator>::type
 {
     typename cont_type::insert_commit_data d;
-    auto const result(m_cont.insert_check(hint.iterator(), extract(value), std::cref(m_config.key_compare()), d));
+    auto const result(
+        m_cont.insert_check(hint.iterator(), extract(value), std::cref(m_config.key_compare()), d));
     if (result.second)
     {
         element* const p(new_element(std::move(value)));
@@ -1452,8 +1577,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, class... Args>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args) ->
-    typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
+    -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1474,8 +1599,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::empla
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, class... Args>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args) ->
-    typename std::enable_if<maybe_multi, iterator>::type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
+    -> typename std::enable_if<maybe_multi, iterator>::type
 {
     element* const p(new_element(std::forward<Args>(args)...));
     auto const before(m_cont.upper_bound(extract(p->value), std::cref(m_config.key_compare())));
@@ -1496,7 +1621,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::empla
     //             construct element here
     element* const p(new_element(std::forward<Args>(args)...));
     typename cont_type::insert_commit_data d;
-    auto const result(m_cont.insert_check(hint.iterator(), extract(p->value), std::cref(m_config.key_compare()), d));
+    auto const result(m_cont.insert_check(
+        hint.iterator(), extract(p->value), std::cref(m_config.key_compare()), d));
     if (result.second)
     {
         auto const iter(m_cont.insert_commit(*p, d));
@@ -1533,7 +1659,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <class K>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(K const& k) -> size_type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(K const& k)
+    -> size_type
 {
     auto iter(m_cont.find(k, std::cref(m_config.key_compare())));
     if (iter == m_cont.end())
@@ -1553,7 +1680,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 void
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap(aged_ordered_container& other) noexcept
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap(
+    aged_ordered_container& other) noexcept
 {
     swap_data(other);
     std::swap(chronological, other.chronological);
@@ -1565,7 +1693,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap(
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <class K>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(K const& k) -> size_type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(K const& k)
+    -> size_type
 {
     auto const now(clock().now());
     size_type n(0);
@@ -1581,13 +1710,31 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
+template <
+    bool OtherIsMulti,
+    bool OtherIsMap,
+    class OtherT,
+    class OtherDuration,
+    class OtherAllocator>
 bool
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator==(
-    aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const& other)
-    const
+    aged_ordered_container<
+        OtherIsMulti,
+        OtherIsMap,
+        Key,
+        OtherT,
+        OtherDuration,
+        Compare,
+        OtherAllocator> const& other) const
 {
-    using Other = aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator>;
+    using Other = aged_ordered_container<
+        OtherIsMulti,
+        OtherIsMap,
+        Key,
+        OtherT,
+        OtherDuration,
+        Compare,
+        OtherAllocator>;
     if (size() != other.size())
         return false;
     std::equal_to<void> eq;
@@ -1642,7 +1789,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap_
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-struct is_aged_container<beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>>
+struct is_aged_container<
+    beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>>
     : std::true_type
 {
     explicit is_aged_container() = default;
@@ -1654,7 +1802,8 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 void
 swap(
     beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>& lhs,
-    beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>& rhs) noexcept
+    beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>&
+        rhs) noexcept
 {
     lhs.swap(rhs);
 }
@@ -1677,7 +1826,8 @@ expire(
 {
     std::size_t n(0);
     auto const expired(c.clock().now() - age);
-    for (auto iter(c.chronological.cbegin()); iter != c.chronological.cend() && iter.when() <= expired;)
+    for (auto iter(c.chronological.cbegin());
+         iter != c.chronological.cend() && iter.when() <= expired;)
     {
         iter = c.erase(iter);
         ++n;