Merge branch 'develop' into a1q123456/spd-log-from-clio

Removed unnecessary include for unistd.h

.clang-tidy

@@ -156,13 +156,7 @@ Checks: "-*,
 # readability-inconsistent-declaration-parameter-name, # in this codebase this check will break a lot of arg names
 # readability-static-accessed-through-instance,        # this check is probably unnecessary. it makes the code less readable
 # ---
-
 CheckOptions:
-  bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
-  bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
-
-  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h"
-
   readability-braces-around-statements.ShortStatementLines: 2
   readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
   readability-identifier-naming.ClassCase: CamelCase
@@ -171,7 +165,7 @@ CheckOptions:
   readability-identifier-naming.EnumCase: CamelCase
   readability-identifier-naming.EnumConstantCase: CamelCase
   readability-identifier-naming.ScopedEnumConstantCase: CamelCase
-  readability-identifier-naming.GlobalConstantCase: CamelCase
+  readability-identifier-naming.GlobalConstantCase: UPPER_CASE
   readability-identifier-naming.GlobalConstantPrefix: "k"
   readability-identifier-naming.GlobalVariableCase: CamelCase
   readability-identifier-naming.GlobalVariablePrefix: "g"
@@ -179,26 +173,27 @@ CheckOptions:
   readability-identifier-naming.ConstexprMethodCase: camelBack
   readability-identifier-naming.ClassMethodCase: camelBack
   readability-identifier-naming.ClassMemberCase: camelBack
-  readability-identifier-naming.ClassConstantCase: CamelCase
+  readability-identifier-naming.ClassConstantCase: UPPER_CASE
   readability-identifier-naming.ClassConstantPrefix: "k"
-  readability-identifier-naming.StaticConstantCase: CamelCase
+  readability-identifier-naming.StaticConstantCase: UPPER_CASE
   readability-identifier-naming.StaticConstantPrefix: "k"
-  readability-identifier-naming.StaticVariableCase: camelBack
-  readability-identifier-naming.ConstexprVariableCase: camelBack
+  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.PrivateMemberCase: camelBack
   readability-identifier-naming.PrivateMemberSuffix: _
-  readability-identifier-naming.ProtectedMemberCase: camelBack
   readability-identifier-naming.ProtectedMemberSuffix: _
-  readability-identifier-naming.PublicMemberCase: camelBack
   readability-identifier-naming.PublicMemberSuffix: ""
   readability-identifier-naming.GlobalFunctionIgnoredRegexp: "^(to_string|hash_append|tuple_hash)$"
-
-HeaderFilterRegex: '^.*/(tests?|xrpl|xrpld)/.*\.(h|hpp|ipp)$'
+  bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
+  bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
+  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h"
+HeaderFilterRegex: '^.*/(test|xrpl|xrpld)/.*\.(h|hpp|ipp)$'
 ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$'
 WarningsAsErrors: "*"

.github/actions/build-deps/action.yml

@@ -37,12 +37,12 @@ runs:
       run: |
         echo 'Installing dependencies.'
         conan install \
-            --profile ci \
-            --build="${BUILD_OPTION}" \
-            --options:host='&:tests=True' \
-            --options:host='&:xrpld=True' \
-            --settings:all build_type="${BUILD_TYPE}" \
-            --conf:all tools.build:jobs=${BUILD_NPROC} \
-            --conf:all tools.build:verbosity="${LOG_VERBOSITY}" \
-            --conf:all tools.compilation:verbosity="${LOG_VERBOSITY}" \
-            .
+          --profile ci \
+          --build="${BUILD_OPTION}" \
+          --options:host='&:tests=True' \
+          --options:host='&:xrpld=True' \
+          --settings:all build_type="${BUILD_TYPE}" \
+          --conf:all tools.build:jobs=${BUILD_NPROC} \
+          --conf:all tools.build:verbosity="${LOG_VERBOSITY}" \
+          --conf:all tools.compilation:verbosity="${LOG_VERBOSITY}" \
+          .

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

@@ -15,7 +15,7 @@ runs:
       shell: bash
       env:
         VERSION: ${{ github.ref_name }}
-      run: echo "VERSION=${VERSION}" >>"${GITHUB_ENV}"
+      run: echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"
 
     # When a tag is not pushed, then the version (e.g. 1.2.3-b0) is extracted
     # from the BuildInfo.cpp file and the shortened commit hash appended to it.
@@ -28,17 +28,17 @@ runs:
         echo 'Extracting version from BuildInfo.cpp.'
         VERSION="$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')"
         if [[ -z "${VERSION}" ]]; then
-            echo 'Unable to extract version from BuildInfo.cpp.'
-            exit 1
+          echo 'Unable to extract version from BuildInfo.cpp.'
+          exit 1
         fi
 
         echo 'Appending shortened commit hash to version.'
         SHA='${{ github.sha }}'
         VERSION="${VERSION}+${SHA:0:7}"
 
-        echo "VERSION=${VERSION}" >>"${GITHUB_ENV}"
+        echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"
 
     - name: Output version
       id: version
       shell: bash
-      run: echo "version=${VERSION}" >>"${GITHUB_OUTPUT}"
+      run: echo "version=${VERSION}" >> "${GITHUB_OUTPUT}"

.github/scripts/format-inline-bash.py

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

.github/scripts/rename/binary.sh

@@ -6,7 +6,7 @@ set -e
 # On MacOS, ensure that GNU sed is installed and available as `gsed`.
 SED_COMMAND=sed
 if [[ "${OSTYPE}" == 'darwin'* ]]; then
-    if ! command -v gsed &>/dev/null; then
+    if ! command -v gsed &> /dev/null; then
         echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
         exit 1
     fi

.github/scripts/rename/cmake.sh

@@ -8,12 +8,12 @@ set -e
 SED_COMMAND=sed
 HEAD_COMMAND=head
 if [[ "${OSTYPE}" == 'darwin'* ]]; then
-    if ! command -v gsed &>/dev/null; then
+    if ! command -v gsed &> /dev/null; then
         echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
         exit 1
     fi
     SED_COMMAND=gsed
-    if ! command -v ghead &>/dev/null; then
+    if ! command -v ghead &> /dev/null; then
         echo "Error: ghead is not installed. Please install it using 'brew install coreutils'."
         exit 1
     fi
@@ -74,10 +74,10 @@ if grep -q '"xrpld"' cmake/XrplCore.cmake; then
     # The script has been rerun, so just restore the name of the binary.
     ${SED_COMMAND} -i 's/"xrpld"/"rippled"/' cmake/XrplCore.cmake
 elif ! grep -q '"rippled"' cmake/XrplCore.cmake; then
-    ${HEAD_COMMAND} -n -1 cmake/XrplCore.cmake >cmake.tmp
-    echo '  # For the time being, we will keep the name of the binary as it was.' >>cmake.tmp
-    echo '  set_target_properties(xrpld PROPERTIES OUTPUT_NAME "rippled")' >>cmake.tmp
-    tail -1 cmake/XrplCore.cmake >>cmake.tmp
+    ${HEAD_COMMAND} -n -1 cmake/XrplCore.cmake > cmake.tmp
+    echo '  # For the time being, we will keep the name of the binary as it was.' >> cmake.tmp
+    echo '  set_target_properties(xrpld PROPERTIES OUTPUT_NAME "rippled")' >> cmake.tmp
+    tail -1 cmake/XrplCore.cmake >> cmake.tmp
     mv cmake.tmp cmake/XrplCore.cmake
 fi
 

.github/scripts/rename/config.sh

@@ -6,7 +6,7 @@ set -e
 # On MacOS, ensure that GNU sed is installed and available as `gsed`.
 SED_COMMAND=sed
 if [[ "${OSTYPE}" == 'darwin'* ]]; then
-    if ! command -v gsed &>/dev/null; then
+    if ! command -v gsed &> /dev/null; then
         echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
         exit 1
     fi
@@ -62,7 +62,7 @@ ${SED_COMMAND} -i 's@ripple/@xrpld/@g' src/test/core/Config_test.cpp
 ${SED_COMMAND} -i 's/Rippled/File/g' src/test/core/Config_test.cpp
 
 # Restore the old config file name in the code that maintains support for now.
-${SED_COMMAND} -i 's/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "rippled.cfg"/g' src/xrpld/core/detail/Config.cpp
+${SED_COMMAND} -i 's/kCONFIG_LEGACY_NAME = "xrpld.cfg"/kCONFIG_LEGACY_NAME = "rippled.cfg"/g' src/xrpld/core/detail/Config.cpp
 
 # Restore an URL.
 ${SED_COMMAND} -i 's/connect-your-xrpld-to-the-xrp-test-net.html/connect-your-rippled-to-the-xrp-test-net.html/g' cfg/xrpld-example.cfg

.github/scripts/rename/copyright.sh

@@ -6,7 +6,7 @@ set -e
 # On MacOS, ensure that GNU sed is installed and available as `gsed`.
 SED_COMMAND=sed
 if [[ "${OSTYPE}" == 'darwin'* ]]; then
-    if ! command -v gsed &>/dev/null; then
+    if ! command -v gsed &> /dev/null; then
         echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
         exit 1
     fi
@@ -62,37 +62,37 @@ done
 # restoring the verbiage that is already present in LICENSE.md. Ensure that if
 # the script is run multiple times, duplicate notices are not added.
 if ! grep -q 'Raw Material Software' include/xrpl/beast/core/CurrentThreadName.h; then
-    echo -e "// Portions of this file are from JUCE (http://www.juce.com).\n// Copyright (c) 2013 - Raw Material Software Ltd.\n// Please visit http://www.juce.com\n\n$(cat include/xrpl/beast/core/CurrentThreadName.h)" >include/xrpl/beast/core/CurrentThreadName.h
+    echo -e "// Portions of this file are from JUCE (http://www.juce.com).\n// Copyright (c) 2013 - Raw Material Software Ltd.\n// Please visit http://www.juce.com\n\n$(cat include/xrpl/beast/core/CurrentThreadName.h)" > include/xrpl/beast/core/CurrentThreadName.h
 fi
 if ! grep -q 'Dev Null' src/test/app/NetworkID_test.cpp; then
-    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/app/NetworkID_test.cpp)" >src/test/app/NetworkID_test.cpp
+    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/app/NetworkID_test.cpp)" > src/test/app/NetworkID_test.cpp
 fi
 if ! grep -q 'Dev Null' src/test/app/tx/apply_test.cpp; then
-    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/app/tx/apply_test.cpp)" >src/test/app/tx/apply_test.cpp
+    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/app/tx/apply_test.cpp)" > src/test/app/tx/apply_test.cpp
 fi
 if ! grep -q 'Dev Null' src/test/rpc/ManifestRPC_test.cpp; then
-    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/rpc/ManifestRPC_test.cpp)" >src/test/rpc/ManifestRPC_test.cpp
+    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/rpc/ManifestRPC_test.cpp)" > src/test/rpc/ManifestRPC_test.cpp
 fi
 if ! grep -q 'Dev Null' src/test/rpc/ValidatorInfo_test.cpp; then
-    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/rpc/ValidatorInfo_test.cpp)" >src/test/rpc/ValidatorInfo_test.cpp
+    echo -e "// Copyright (c) 2020 Dev Null Productions\n\n$(cat src/test/rpc/ValidatorInfo_test.cpp)" > src/test/rpc/ValidatorInfo_test.cpp
 fi
 if ! grep -q 'Dev Null' src/xrpld/rpc/handlers/server_info/Manifest.cpp; then
-    echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/server_info/Manifest.cpp)" >src/xrpld/rpc/handlers/server_info/Manifest.cpp
+    echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/server_info/Manifest.cpp)" > src/xrpld/rpc/handlers/server_info/Manifest.cpp
 fi
 if ! grep -q 'Dev Null' src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp; then
-    echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp)" >src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp
+    echo -e "// Copyright (c) 2019 Dev Null Productions\n\n$(cat src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp)" > src/xrpld/rpc/handlers/admin/status/ValidatorInfo.cpp
 fi
 if ! grep -q 'Bougalis' include/xrpl/basics/SlabAllocator.h; then
-    echo -e "// Copyright (c) 2022, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/SlabAllocator.h)" >include/xrpl/basics/SlabAllocator.h # cspell: ignore Nikolaos Bougalis nikb
+    echo -e "// Copyright (c) 2022, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/SlabAllocator.h)" > include/xrpl/basics/SlabAllocator.h # cspell: ignore Nikolaos Bougalis nikb
 fi
 if ! grep -q 'Bougalis' include/xrpl/basics/spinlock.h; then
-    echo -e "// Copyright (c) 2022, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/spinlock.h)" >include/xrpl/basics/spinlock.h # cspell: ignore Nikolaos Bougalis nikb
+    echo -e "// Copyright (c) 2022, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/spinlock.h)" > include/xrpl/basics/spinlock.h # cspell: ignore Nikolaos Bougalis nikb
 fi
 if ! grep -q 'Bougalis' include/xrpl/basics/tagged_integer.h; then
-    echo -e "// Copyright (c) 2014, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/tagged_integer.h)" >include/xrpl/basics/tagged_integer.h # cspell: ignore Nikolaos Bougalis nikb
+    echo -e "// Copyright (c) 2014, Nikolaos D. Bougalis <nikb@bougalis.net>\n\n$(cat include/xrpl/basics/tagged_integer.h)" > include/xrpl/basics/tagged_integer.h # cspell: ignore Nikolaos Bougalis nikb
 fi
 if ! grep -q 'Ritchford' include/xrpl/beast/utility/Zero.h; then
-    echo -e "// Copyright (c) 2014, Tom Ritchford <tom@swirly.com>\n\n$(cat include/xrpl/beast/utility/Zero.h)" >include/xrpl/beast/utility/Zero.h # cspell: ignore Ritchford
+    echo -e "// Copyright (c) 2014, Tom Ritchford <tom@swirly.com>\n\n$(cat include/xrpl/beast/utility/Zero.h)" > include/xrpl/beast/utility/Zero.h # cspell: ignore Ritchford
 fi
 
 # Restore newlines and tabs in string literals in the affected file.

.github/scripts/rename/definitions.sh

@@ -6,7 +6,7 @@ set -e
 # On MacOS, ensure that GNU sed is installed and available as `gsed`.
 SED_COMMAND=sed
 if [[ "${OSTYPE}" == 'darwin'* ]]; then
-    if ! command -v gsed &>/dev/null; then
+    if ! command -v gsed &> /dev/null; then
         echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
         exit 1
     fi

.github/scripts/rename/docs.sh

@@ -6,7 +6,7 @@ set -e
 # On MacOS, ensure that GNU sed is installed and available as `gsed`.
 SED_COMMAND=sed
 if [[ "${OSTYPE}" == 'darwin'* ]]; then
-    if ! command -v gsed &>/dev/null; then
+    if ! command -v gsed &> /dev/null; then
         echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
         exit 1
     fi
@@ -90,7 +90,7 @@ ${SED_COMMAND} -i 's/www.ripple.com/www.xrpl.org/g' src/test/protocol/Seed_test.
 # Restore specific changes.
 ${SED_COMMAND} -i 's@b5efcc/src/xrpld@b5efcc/src/ripple@' include/xrpl/protocol/README.md
 ${SED_COMMAND} -i 's/dbPrefix_ = "xrpldb"/dbPrefix_ = "rippledb"/' src/xrpld/app/misc/SHAMapStoreImp.h # cspell: disable-line
-${SED_COMMAND} -i 's/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "rippled.cfg"/' src/xrpld/core/detail/Config.cpp
+${SED_COMMAND} -i 's/kCONFIG_LEGACY_NAME = "xrpld.cfg"/kCONFIG_LEGACY_NAME = "rippled.cfg"/' src/xrpld/core/detail/Config.cpp
 
 popd
 echo "Renaming complete."

.github/scripts/rename/namespace.sh

@@ -6,7 +6,7 @@ set -e
 # On MacOS, ensure that GNU sed is installed and available as `gsed`.
 SED_COMMAND=sed
 if [[ "${OSTYPE}" == 'darwin'* ]]; then
-    if ! command -v gsed &>/dev/null; then
+    if ! command -v gsed &> /dev/null; then
         echo "Error: gsed is not installed. Please install it using 'brew install gnu-sed'."
         exit 1
     fi

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

@@ -32,32 +32,7 @@ We will further set additional CMake arguments as follows:
 """
 
 
-def build_config_name(os_entry: dict[str, str], platform: str, build_type: str) -> str:
-    parts = [os_entry["distro_name"]]
-    for key in ("distro_version", "compiler_name", "compiler_version"):
-        if value := os_entry[key]:
-            parts.append(value)
-    parts.append("arm64" if "arm64" in platform else "amd64")
-    parts.append(build_type.lower())
-    return "-".join(parts)
-
-
-def generate_packaging_matrix(config: Config) -> list[dict]:
-    """Emit one entry per os entry with `package: true`. Architecture is
-    hardcoded to linux/amd64 here (and the runner is hardcoded at the
-    workflow level) until arm64 packaging is ready.
-    """
-    return [
-        {
-            "artifact_name": f"xrpld-{build_config_name(os, 'linux/amd64', 'Release')}",
-            "os": os,
-        }
-        for os in config.os
-        if os.get("package", False)
-    ]
-
-
-def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
+def generate_strategy_matrix(all: bool, config: Config) -> list:
     configurations = []
     for architecture, os, build_type, cmake_args in itertools.product(
         config.architecture, config.os, config.build_type, config.cmake_args
@@ -97,7 +72,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
                         skip = False
                     if (
                         f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15"
-                        and build_type == "Release"
+                        and build_type == "Debug"
                         and architecture["platform"] == "linux/amd64"
                     ):
                         skip = False
@@ -115,9 +90,8 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
                     ):
                         cmake_args = f"-DUNIT_TEST_REFERENCE_FEE=1000 {cmake_args}"
                         skip = False
-                elif os["distro_version"] == "trixie":
                     if (
-                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22"
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-20"
                         and build_type == "Debug"
                         and architecture["platform"] == "linux/amd64"
                     ):
@@ -126,15 +100,14 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
                     continue
 
             # RHEL:
-            # - 9 using GCC 12: Debug and Release on linux/amd64
-            #   (Release is required for RPM packaging).
+            # - 9 using GCC 12: Debug on linux/amd64.
             # - 10 using Clang: Release on linux/amd64.
             if os["distro_name"] == "rhel":
                 skip = True
                 if os["distro_version"] == "9":
                     if (
                         f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
-                        and build_type in ["Debug", "Release"]
+                        and build_type == "Debug"
                         and architecture["platform"] == "linux/amd64"
                     ):
                         skip = False
@@ -149,8 +122,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
                     continue
 
             # Ubuntu:
-            # - Jammy using GCC 12: Debug on linux/arm64, Release on
-            #   linux/amd64 (Release is required for DEB packaging).
+            # - Jammy using GCC 12: Debug on linux/arm64.
             # - Noble using GCC 14: Release on linux/amd64.
             # - Noble using Clang 18: Debug on linux/amd64.
             # - Noble using Clang 19: Release on linux/arm64.
@@ -163,12 +135,6 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
                         and architecture["platform"] == "linux/arm64"
                     ):
                         skip = False
-                    if (
-                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
-                        and build_type == "Release"
-                        and architecture["platform"] == "linux/amd64"
-                    ):
-                        skip = False
                 elif os["distro_version"] == "noble":
                     if (
                         f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-14"
@@ -222,9 +188,8 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
 
         # We skip all clang 20+ on arm64 due to Boost build error.
         if (
-            os["compiler_name"] == "clang"
-            and os["compiler_version"].isdigit()
-            and int(os["compiler_version"]) >= 20
+            f"{os['compiler_name']}-{os['compiler_version']}"
+            in ["clang-20", "clang-21"]
             and architecture["platform"] == "linux/arm64"
         ):
             continue
@@ -251,7 +216,17 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
 
         # Generate a unique name for the configuration, e.g. macos-arm64-debug
         # or debian-bookworm-gcc-12-amd64-release.
-        config_name = build_config_name(os, architecture["platform"], build_type)
+        config_name = os["distro_name"]
+        if (n := os["distro_version"]) != "":
+            config_name += f"-{n}"
+        if (n := os["compiler_name"]) != "":
+            config_name += f"-{n}"
+        if (n := os["compiler_version"]) != "":
+            config_name += f"-{n}"
+        config_name += (
+            f"-{architecture['platform'][architecture['platform'].find('/')+1:]}"
+        )
+        config_name += f"-{build_type.lower()}"
         if "-Dcoverage=ON" in cmake_args:
             config_name += "-coverage"
         if "-Dunity=ON" in cmake_args:
@@ -263,14 +238,13 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
         # Add Address and UB sanitizers as separate configurations for specific
         # bookworm distros. Thread sanitizer is currently disabled (see below).
         # GCC-Asan xrpld-embedded tests are failing because of https://github.com/google/sanitizers/issues/856
-        if (
-            os["distro_version"] == "bookworm"
-            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15"
-        ) or (
-            os["distro_version"] == "trixie"
-            and f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22"
-        ):
-            # Add ASAN and UBSAN configurations for both gcc-15 and clang-22
+        if os[
+            "distro_version"
+        ] == "bookworm" and f"{os['compiler_name']}-{os['compiler_version']}" in [
+            "gcc-15",
+            "clang-20",
+        ]:
+            # Add ASAN configuration.
             configurations.append(
                 {
                     "config_name": config_name + "-asan",
@@ -283,6 +257,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
                     "sanitizers": "address",
                 }
             )
+            # Add UBSAN configuration.
             configurations.append(
                 {
                     "config_name": config_name + "-ubsan",
@@ -355,19 +330,10 @@ if __name__ == "__main__":
         required=False,
         type=Path,
     )
-    parser.add_argument(
-        "-p",
-        "--packaging",
-        help="Emit the packaging matrix (derived from the 'package' field on os entries) instead of the build/test matrix.",
-        action="store_true",
-    )
     args = parser.parse_args()
 
     matrix = []
-    if args.packaging:
-        config_path = args.config if args.config else THIS_DIR / "linux.json"
-        matrix += generate_packaging_matrix(read_config(config_path))
-    elif args.config is None or args.config == "":
+    if args.config is None or args.config == "":
         matrix += generate_strategy_matrix(
             args.all, read_config(THIS_DIR / "linux.json")
         )

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

@@ -15,205 +15,196 @@
       "distro_version": "bookworm",
       "compiler_name": "gcc",
       "compiler_version": "12",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "bookworm",
       "compiler_name": "gcc",
       "compiler_version": "13",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "bookworm",
       "compiler_name": "gcc",
       "compiler_version": "14",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "bookworm",
       "compiler_name": "gcc",
       "compiler_version": "15",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "bookworm",
       "compiler_name": "clang",
       "compiler_version": "16",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "bookworm",
       "compiler_name": "clang",
       "compiler_version": "17",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "bookworm",
       "compiler_name": "clang",
       "compiler_version": "18",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "bookworm",
       "compiler_name": "clang",
       "compiler_version": "19",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "bookworm",
       "compiler_name": "clang",
       "compiler_version": "20",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "trixie",
       "compiler_name": "gcc",
       "compiler_version": "14",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "trixie",
       "compiler_name": "gcc",
       "compiler_version": "15",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "trixie",
       "compiler_name": "clang",
       "compiler_version": "20",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "debian",
       "distro_version": "trixie",
       "compiler_name": "clang",
       "compiler_version": "21",
-      "image_sha": "4c086b9"
-    },
-    {
-      "distro_name": "debian",
-      "distro_version": "trixie",
-      "compiler_name": "clang",
-      "compiler_version": "22",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "rhel",
       "distro_version": "8",
       "compiler_name": "gcc",
       "compiler_version": "14",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "rhel",
       "distro_version": "8",
       "compiler_name": "clang",
       "compiler_version": "any",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "rhel",
       "distro_version": "9",
       "compiler_name": "gcc",
       "compiler_version": "12",
-      "image_sha": "4c086b9",
-      "package": true
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "rhel",
       "distro_version": "9",
       "compiler_name": "gcc",
       "compiler_version": "13",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "rhel",
       "distro_version": "9",
       "compiler_name": "gcc",
       "compiler_version": "14",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "rhel",
       "distro_version": "9",
       "compiler_name": "clang",
       "compiler_version": "any",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "rhel",
       "distro_version": "10",
       "compiler_name": "gcc",
       "compiler_version": "14",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "rhel",
       "distro_version": "10",
       "compiler_name": "clang",
       "compiler_version": "any",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "ubuntu",
       "distro_version": "jammy",
       "compiler_name": "gcc",
       "compiler_version": "12",
-      "image_sha": "4c086b9",
-      "package": true
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "ubuntu",
       "distro_version": "noble",
       "compiler_name": "gcc",
       "compiler_version": "13",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "ubuntu",
       "distro_version": "noble",
       "compiler_name": "gcc",
       "compiler_version": "14",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "ubuntu",
       "distro_version": "noble",
       "compiler_name": "clang",
       "compiler_version": "16",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "ubuntu",
       "distro_version": "noble",
       "compiler_name": "clang",
       "compiler_version": "17",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "ubuntu",
       "distro_version": "noble",
       "compiler_name": "clang",
       "compiler_version": "18",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     },
     {
       "distro_name": "ubuntu",
       "distro_version": "noble",
       "compiler_name": "clang",
       "compiler_version": "19",
-      "image_sha": "4c086b9"
+      "image_sha": "ab4d1f0"
     }
   ],
   "build_type": ["Debug", "Release"],

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

@@ -1,109 +0,0 @@
-name: Build Nix Docker image
-
-on:
-  push:
-    branches:
-      - develop
-    paths:
-      - ".github/workflows/build-nix-image.yml"
-      - ".github/workflows/reusable-build-docker-image.yml"
-      - "docker/**"
-      - "flake.nix"
-      - "flake.lock"
-      - "nix/**"
-  pull_request:
-    paths:
-      - ".github/workflows/build-nix-image.yml"
-      - ".github/workflows/reusable-build-docker-image.yml"
-      - "docker/**"
-      - "flake.nix"
-      - "flake.lock"
-      - "nix/**"
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  build:
-    name: Build ${{ matrix.distro.name }} (${{ matrix.target.platform }})
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        # The base images are the oldest supported version of each distro
-        # that we want to build images for.
-        distro:
-          - name: nixos
-            base_image: nixos/nix:latest
-          - name: ubuntu
-            base_image: ubuntu:20.04
-          - name: rhel
-            base_image: registry.access.redhat.com/ubi9/ubi:latest
-          - name: debian
-            base_image: debian:bookworm
-        target:
-          - platform: linux/amd64
-            runner: ubuntu-latest
-          - platform: linux/arm64
-            runner: ubuntu-24.04-arm
-    uses: ./.github/workflows/reusable-build-docker-image.yml
-    with:
-      image_name: ghcr.io/xrplf/xrpld/nix-${{ matrix.distro.name }}
-      dockerfile: docker/nix.Dockerfile
-      base_image: ${{ matrix.distro.base_image }}
-      platform: ${{ matrix.target.platform }}
-      runner: ${{ matrix.target.runner }}
-      push: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' }}
-
-  merge:
-    name: Merge ${{ matrix.distro }} manifest
-    needs: build
-    if: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' }}
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        distro: [nixos, ubuntu, rhel, debian]
-    env:
-      IMAGE_NAME: ghcr.io/xrplf/xrpld/nix-${{ matrix.distro }}
-
-    steps:
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
-
-      - name: Docker metadata
-        id: meta
-        uses: docker/metadata-action@80c7e94dd9b9319bd5eb7a0e0fe9291e23a2a2e9 # v6.1.0
-        with:
-          images: ${{ env.IMAGE_NAME }}
-          tags: |
-            type=sha,prefix=sha-,format=short
-            type=raw,value=latest
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Create multi-arch manifests
-        run: |
-          for tag in $(jq -cr '.tags[]' <<<"$DOCKER_METADATA_OUTPUT_JSON"); do
-              docker buildx imagetools create -t "$tag" "${tag}-amd64" "${tag}-arm64"
-          done
-
-      - name: Inspect image
-        run: |
-          docker buildx imagetools inspect "${IMAGE_NAME}:${{ steps.meta.outputs.version }}"

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

@@ -5,17 +5,8 @@ on:
     types:
       - checks_requested
   pull_request:
-    types:
-      - opened
-      - edited
-      - reopened
-      - synchronize
-      - ready_for_review
-    branches:
-      - develop
-      - "release-*"
-      - "release/*"
-      - "staging/*"
+    types: [opened, edited, reopened, synchronize, ready_for_review]
+    branches: [develop]
 
 jobs:
   check_description:
@@ -29,11 +20,11 @@ jobs:
         env:
           PR_BODY: ${{ github.event.pull_request.body }}
         if: ${{ github.event_name == 'pull_request' }}
-        run: printenv PR_BODY >pr_body.md
+        run: printenv PR_BODY > pr_body.md
 
       - name: Check PR description differs from template
         if: ${{ github.event_name == 'pull_request' }}
-        run: |
-          python .github/scripts/check-pr-description.py \
-              --template-file .github/pull_request_template.md \
-              --pr-body-file pr_body.md
+        run: >
+          python .github/scripts/check-pr-description.py
+          --template-file .github/pull_request_template.md
+          --pr-body-file pr_body.md

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

@@ -5,19 +5,10 @@ on:
     types:
       - checks_requested
   pull_request:
-    types:
-      - opened
-      - edited
-      - reopened
-      - synchronize
-      - ready_for_review
-    branches:
-      - develop
-      - "release-*"
-      - "release/*"
-      - "staging/*"
+    types: [opened, edited, reopened, synchronize, ready_for_review]
+    branches: [develop]
 
 jobs:
   check_title:
     if: ${{ github.event.pull_request.draft != true }}
-    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@cba1f0891650baf1a9c88624dc2d72573be2eb81
+    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@a5d8dd35be543365e90a11358447130c8763871d

.github/workflows/conflicting-pr.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check if PRs are dirty
-        uses: eps1lon/actions-label-merge-conflict@0273be72a0bbd58fcd71d0d6c02c209b50d1e5e1 # v3.1.0
+        uses: eps1lon/actions-label-merge-conflict@1df065ebe6e3310545d4f4c4e862e43bdca146f0 # v3.0.3
         with:
           dirtyLabel: "PR: has conflicts"
           repoToken: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/on-pr.yml

@@ -64,13 +64,11 @@ jobs:
             .github/workflows/reusable-build-test-config.yml
             .github/workflows/reusable-build-test.yml
             .github/workflows/reusable-clang-tidy.yml
-            .github/workflows/reusable-package.yml
             .github/workflows/reusable-strategy-matrix.yml
             .github/workflows/reusable-test.yml
             .github/workflows/reusable-upload-recipe.yml
             .clang-tidy
             .codecov.yml
-            cfg/**
             cmake/**
             conan/**
             external/**
@@ -80,10 +78,6 @@ jobs:
             CMakeLists.txt
             conanfile.py
             conan.lock
-            LICENSE.md
-            package/**
-            README.md
-
       - name: Check whether to run
         # This step determines whether the rest of the workflow should
         # run. The rest of the workflow will run if this job runs AND at
@@ -98,7 +92,7 @@ jobs:
           READY: ${{ contains(github.event.pull_request.labels.*.name, 'Ready to merge') }}
           MERGE: ${{ github.event_name == 'merge_group' }}
         run: |
-          echo "go=${{ (env.DRAFT != 'true' && env.READY == 'true') || env.FILES == 'true' || env.MERGE == 'true' }}" >>"${GITHUB_OUTPUT}"
+          echo "go=${{ (env.DRAFT != 'true' && env.READY == 'true') || env.FILES == 'true' || env.MERGE == 'true' }}" >> "${GITHUB_OUTPUT}"
           cat "${GITHUB_OUTPUT}"
     outputs:
       go: ${{ steps.go.outputs.go == 'true' }}
@@ -140,11 +134,6 @@ jobs:
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
-  package:
-    needs: [should-run, build-test]
-    if: ${{ needs.should-run.outputs.go == 'true' }}
-    uses: ./.github/workflows/reusable-package.yml
-
   upload-recipe:
     needs:
       - should-run
@@ -168,9 +157,9 @@ jobs:
           PR_URL: ${{ github.event.pull_request.html_url }}
         run: |
           gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
-              /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
-              -F "client_payload[ref]=${{ needs.upload-recipe.outputs.recipe_ref }}" \
-              -F "client_payload[pr_url]=${PR_URL}"
+          /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
+          -F "client_payload[ref]=${{ needs.upload-recipe.outputs.recipe_ref }}" \
+          -F "client_payload[pr_url]=${PR_URL}"
 
   passed:
     if: failure() || cancelled()
@@ -179,7 +168,6 @@ jobs:
       - check-rename
       - clang-tidy
       - build-test
-      - package
       - upload-recipe
       - notify-clio
     runs-on: ubuntu-latest

.github/workflows/on-tag.yml

@@ -1,5 +1,5 @@
-# This workflow uploads the libxrpl recipe to the Conan remote and builds
-# release packages when a versioned tag is pushed.
+# This workflow uploads the libxrpl recipe to the Conan remote when a versioned
+# tag is pushed.
 name: Tag
 
 on:
@@ -22,22 +22,3 @@ jobs:
     secrets:
       remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
       remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}
-
-  build-test:
-    if: ${{ github.repository == 'XRPLF/rippled' }}
-    uses: ./.github/workflows/reusable-build-test.yml
-    strategy:
-      fail-fast: true
-      matrix:
-        os: [linux]
-    with:
-      ccache_enabled: false
-      os: ${{ matrix.os }}
-      strategy_matrix: minimal
-    secrets:
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-  package:
-    if: ${{ github.repository == 'XRPLF/rippled' }}
-    needs: build-test
-    uses: ./.github/workflows/reusable-package.yml

.github/workflows/on-trigger.yml

@@ -21,13 +21,11 @@ on:
       - ".github/workflows/reusable-build-test-config.yml"
       - ".github/workflows/reusable-build-test.yml"
       - ".github/workflows/reusable-clang-tidy.yml"
-      - ".github/workflows/reusable-package.yml"
       - ".github/workflows/reusable-strategy-matrix.yml"
       - ".github/workflows/reusable-test.yml"
       - ".github/workflows/reusable-upload-recipe.yml"
       - ".clang-tidy"
       - ".codecov.yml"
-      - "cfg/**"
       - "cmake/**"
       - "conan/**"
       - "external/**"
@@ -37,9 +35,6 @@ on:
       - "CMakeLists.txt"
       - "conanfile.py"
       - "conan.lock"
-      - "LICENSE.md"
-      - "package/**"
-      - "README.md"
 
   # Run at 06:32 UTC on every day of the week from Monday through Friday. This
   # will force all dependencies to be rebuilt, which is useful to verify that
@@ -100,7 +95,3 @@ jobs:
     secrets:
       remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
       remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}
-
-  package:
-    needs: build-test
-    uses: ./.github/workflows/reusable-package.yml

.github/workflows/pre-commit.yml

@@ -14,7 +14,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@cba1f0891650baf1a9c88624dc2d72573be2eb81
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@5e942d61bf32f7557a7c159cfac4712a687b3e3a
     with:
       runs_on: ubuntu-latest
       container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'

.github/workflows/reusable-build-docker-image.yml

@@ -1,89 +0,0 @@
-# Build a single-platform Docker image. On push, the image is pushed to
-# GHCR with arch-suffixed tags (e.g. `:latest-amd64`, `:sha-abc-amd64`)
-# so the calling workflow can stitch per-arch builds into a multi-arch
-# manifest without needing to pass digests around.
-name: Reusable build Docker image (single platform)
-
-on:
-  workflow_call:
-    inputs:
-      image_name:
-        description: "Full image name without tag (e.g. 'ghcr.io/xrplf/xrpld/nix-ubuntu')"
-        required: true
-        type: string
-      dockerfile:
-        description: "Path to the Dockerfile, relative to the repository root"
-        required: true
-        type: string
-      base_image:
-        description: "Value passed to the Dockerfile as the BASE_IMAGE build arg"
-        required: true
-        type: string
-      platform:
-        description: "Docker platform string, e.g. linux/amd64"
-        required: true
-        type: string
-      runner:
-        description: "GitHub Actions runner label to build on"
-        required: true
-        type: string
-      push:
-        description: "Whether to push the image to GHCR"
-        required: true
-        type: boolean
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  build:
-    name: Build (${{ inputs.platform }})
-    runs-on: ${{ inputs.runner }}
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - name: Determine arch
-        id: vars
-        env:
-          PLATFORM: ${{ inputs.platform }}
-        run: |
-          echo "arch=${PLATFORM##*/}" >>$GITHUB_OUTPUT
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
-
-      - name: Login to GitHub Container Registry
-        if: inputs.push
-        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Docker metadata
-        id: meta
-        uses: docker/metadata-action@80c7e94dd9b9319bd5eb7a0e0fe9291e23a2a2e9 # v6.1.0
-        with:
-          images: ${{ inputs.image_name }}
-          tags: |
-            type=sha,prefix=sha-,format=short
-            type=raw,value=latest
-          flavor: |
-            suffix=-${{ steps.vars.outputs.arch }},onlatest=true
-
-      - name: Build and push
-        uses: docker/build-push-action@f9f3042f7e2789586610d6e8b85c8f03e5195baf # v7.2.0
-        with:
-          context: .
-          file: ${{ inputs.dockerfile }}
-          platforms: ${{ inputs.platform }}
-          push: ${{ inputs.push }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          build-args: BASE_IMAGE=${{ inputs.base_image }}

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

@@ -113,7 +113,7 @@ jobs:
 
       - name: Set ccache log file
         if: ${{ inputs.ccache_enabled && runner.debug == '1' }}
-        run: echo "CCACHE_LOGFILE=${{ runner.temp }}/ccache.log" >>"${GITHUB_ENV}"
+        run: echo "CCACHE_LOGFILE=${{ runner.temp }}/ccache.log" >> "${GITHUB_ENV}"
 
       - name: Print build environment
         uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574
@@ -146,11 +146,11 @@ jobs:
           CMAKE_ARGS: ${{ inputs.cmake_args }}
         run: |
           cmake \
-              -G '${{ runner.os == 'Windows' && 'Visual Studio 17 2022' || 'Ninja' }}' \
-              -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
-              -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
-              ${CMAKE_ARGS} \
-              ..
+            -G '${{ runner.os == 'Windows' && 'Visual Studio 17 2022' || 'Ninja' }}' \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+            ${CMAKE_ARGS} \
+            ..
 
       - name: Check protocol autogen files are up-to-date
         working-directory: ${{ env.BUILD_DIR }}
@@ -172,10 +172,10 @@ jobs:
           cmake --build . --target code_gen
           DIFF=$(git -C .. status --porcelain -- include/xrpl/protocol_autogen src/tests/libxrpl/protocol_autogen)
           if [ -n "${DIFF}" ]; then
-              echo "::error::Generated protocol files are out of date"
-              git -C .. diff -- include/xrpl/protocol_autogen src/tests/libxrpl/protocol_autogen
-              echo "${MESSAGE}"
-              exit 1
+            echo "::error::Generated protocol files are out of date"
+            git -C .. diff -- include/xrpl/protocol_autogen src/tests/libxrpl/protocol_autogen
+            echo "${MESSAGE}"
+            exit 1
           fi
 
       - name: Build the binary
@@ -186,18 +186,18 @@ jobs:
           CMAKE_TARGET: ${{ inputs.cmake_target }}
         run: |
           cmake \
-              --build . \
-              --config "${BUILD_TYPE}" \
-              --parallel "${BUILD_NPROC}" \
-              --target "${CMAKE_TARGET}"
+            --build . \
+            --config "${BUILD_TYPE}" \
+            --parallel "${BUILD_NPROC}" \
+            --target "${CMAKE_TARGET}"
 
       - name: Show ccache statistics
         if: ${{ inputs.ccache_enabled }}
         run: |
           ccache --show-stats -vv
           if [ '${{ runner.debug }}' = '1' ]; then
-              cat "${CCACHE_LOGFILE}"
-              curl ${CCACHE_REMOTE_STORAGE%|*}/status || true
+            cat "${CCACHE_LOGFILE}"
+            curl ${CCACHE_REMOTE_STORAGE%|*}/status || true
           fi
 
       - name: Upload the binary (Linux)
@@ -214,7 +214,7 @@ jobs:
         working-directory: ${{ env.BUILD_DIR }}
         run: |
           set -o pipefail
-          ./xrpld --definitions | python3 -m json.tool >server_definitions.json
+          ./xrpld --definitions | python3 -m json.tool > server_definitions.json
 
       - name: Upload server definitions
         if: ${{ github.event.repository.visibility == 'public' && inputs.config_name == 'debian-bookworm-gcc-13-amd64-release' }}
@@ -231,10 +231,10 @@ jobs:
         run: |
           ldd ./xrpld
           if [ "$(ldd ./xrpld | grep -E '(libstdc\+\+|libgcc)' | wc -l)" -eq 0 ]; then
-              echo 'The binary is statically linked.'
+            echo 'The binary is statically linked.'
           else
-              echo 'The binary is dynamically linked.'
-              exit 1
+            echo 'The binary is dynamically linked.'
+            exit 1
           fi
 
       - name: Verify presence of instrumentation (Linux)
@@ -250,12 +250,12 @@ jobs:
         run: |
           ASAN_OPTS="include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-asan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp"
           if [[ "${CONFIG_NAME}" == *gcc* ]]; then
-              ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
+            ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
           fi
-          echo "ASAN_OPTIONS=${ASAN_OPTS}" >>${GITHUB_ENV}
-          echo "TSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-tsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >>${GITHUB_ENV}
-          echo "UBSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >>${GITHUB_ENV}
-          echo "LSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-lsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >>${GITHUB_ENV}
+          echo "ASAN_OPTIONS=${ASAN_OPTS}" >> ${GITHUB_ENV}
+          echo "TSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-tsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >> ${GITHUB_ENV}
+          echo "UBSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >> ${GITHUB_ENV}
+          echo "LSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-lsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >> ${GITHUB_ENV}
 
       - name: Run the separate tests
         if: ${{ !inputs.build_only }}
@@ -266,9 +266,9 @@ jobs:
           PARALLELISM: ${{ runner.os == 'Windows' && '1' || steps.nproc.outputs.nproc }}
         run: |
           ctest \
-              --output-on-failure \
-              -C "${BUILD_TYPE}" \
-              -j "${PARALLELISM}"
+            --output-on-failure \
+            -C "${BUILD_TYPE}" \
+            -j "${PARALLELISM}"
 
       - name: Run the embedded tests
         if: ${{ !inputs.build_only }}
@@ -278,28 +278,20 @@ jobs:
         run: |
           set -o pipefail
           # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
-          [ "$COVERAGE_ENABLED" = "true" ] && BUILD_NPROC=$((BUILD_NPROC - 2))
+          [ "$COVERAGE_ENABLED" = "true" ] && BUILD_NPROC=$(( BUILD_NPROC - 2 ))
           ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee unittest.log
 
       - name: Show test failure summary
         if: ${{ failure() && !inputs.build_only }}
-        env:
-          WORKING_DIR: ${{ runner.os == 'Windows' && format('{0}\{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
+        working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
         run: |
-          if [ ! -d "${WORKING_DIR}" ]; then
-              echo "Working directory '${WORKING_DIR}' does not exist."
-              exit 0
-          fi
-
-          cd "${WORKING_DIR}"
-
           if [ ! -f unittest.log ]; then
-              echo "unittest.log not found; embedded tests may not have run."
-              exit 0
+            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."
+            echo "Log present but no failure lines found in unittest.log."
           fi
       - name: Debug failure (Linux)
         if: ${{ failure() && runner.os == 'Linux' && !inputs.build_only }}
@@ -317,14 +309,14 @@ jobs:
           BUILD_TYPE: ${{ inputs.build_type }}
         run: |
           cmake \
-              --build . \
-              --config "${BUILD_TYPE}" \
-              --parallel "${BUILD_NPROC}" \
-              --target coverage
+            --build . \
+            --config "${BUILD_TYPE}" \
+            --parallel "${BUILD_NPROC}" \
+            --target coverage
 
       - name: Upload coverage report
         if: ${{ github.repository == 'XRPLF/rippled' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
-        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1
+        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
         with:
           disable_search: true
           disable_telem: true

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

@@ -38,9 +38,9 @@ jobs:
         run: |
           DIFF=$(git status --porcelain)
           if [ -n "${DIFF}" ]; then
-              # Print the differences to give the contributor a hint about what to
-              # expect when running levelization on their own machine.
-              git diff
-              echo "${MESSAGE}"
-              exit 1
+            # Print the differences to give the contributor a hint about what to
+            # expect when running levelization on their own machine.
+            git diff
+            echo "${MESSAGE}"
+            exit 1
           fi

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

@@ -48,9 +48,9 @@ jobs:
         run: |
           DIFF=$(git status --porcelain)
           if [ -n "${DIFF}" ]; then
-              # Print the differences to give the contributor a hint about what to
-              # expect when running the renaming scripts on their own machine.
-              git diff
-              echo "${MESSAGE}"
-              exit 1
+            # Print the differences to give the contributor a hint about what to
+            # expect when running the renaming scripts on their own machine.
+            git diff
+            echo "${MESSAGE}"
+            exit 1
           fi

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

@@ -29,7 +29,7 @@ jobs:
     if: ${{ inputs.check_only_changed }}
     permissions:
       contents: read
-    uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@224f3c48d3014d082a1129237b8291ff0b0a331f
+    uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@12f5dbc98a2260259a66970e57fa4d26fb7f285c
 
   run-clang-tidy:
     name: Run clang tidy
@@ -70,13 +70,13 @@ jobs:
         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 \
-              ..
+            -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
@@ -133,7 +133,7 @@ jobs:
       - name: Write issue header
         if: ${{ steps.run_clang_tidy.outcome != 'success' }}
         run: |
-          cat >"${ISSUE_FILE}" <<EOF
+          cat > "${ISSUE_FILE}" <<EOF
           ## Clang-tidy Check Failed
 
           ### Clang-tidy Output:
@@ -144,30 +144,30 @@ jobs:
         if: ${{ steps.run_clang_tidy.outcome != 'success' }}
         run: |
           if [ -f "${OUTPUT_FILE}" ]; then
-              # Extract lines containing 'error:', 'warning:', or 'note:'
-              grep -E '(error:|warning:|note:)' "${OUTPUT_FILE}" >filtered-output.txt || true
+            # Extract lines containing 'error:', 'warning:', or 'note:'
+            grep -E '(error:|warning:|note:)' "${OUTPUT_FILE}" > filtered-output.txt || true
 
-              # If filtered output is empty, use original (might be a different error format)
-              if [ ! -s filtered-output.txt ]; then
-                  cp "${OUTPUT_FILE}" filtered-output.txt
-              fi
+            # If filtered output is empty, use original (might be a different error format)
+            if [ ! -s filtered-output.txt ]; then
+              cp "${OUTPUT_FILE}" filtered-output.txt
+            fi
 
-              # Truncate if too large
-              head -c 60000 filtered-output.txt >>"${ISSUE_FILE}"
-              if [ "$(wc -c <filtered-output.txt)" -gt 60000 ]; then
-                  echo "" >>"${ISSUE_FILE}"
-                  echo "... (output truncated, see artifacts for full output)" >>"${ISSUE_FILE}"
-              fi
+            # Truncate if too large
+            head -c 60000 filtered-output.txt >> "${ISSUE_FILE}"
+            if [ "$(wc -c < filtered-output.txt)" -gt 60000 ]; then
+              echo "" >> "${ISSUE_FILE}"
+              echo "... (output truncated, see artifacts for full output)" >> "${ISSUE_FILE}"
+            fi
 
-              rm filtered-output.txt
+            rm filtered-output.txt
           else
-              echo "No output file found" >>"${ISSUE_FILE}"
+            echo "No output file found" >> "${ISSUE_FILE}"
           fi
 
       - name: Append issue footer
         if: ${{ steps.run_clang_tidy.outcome != 'success' }}
         run: |
-          cat >>"${ISSUE_FILE}" <<EOF
+          cat >> "${ISSUE_FILE}" <<EOF
           \`\`\`
 
           ---
@@ -176,7 +176,7 @@ jobs:
 
       - name: Create issue
         if: ${{ steps.run_clang_tidy.outcome != 'success' && inputs.create_issue_on_failure }}
-        uses: XRPLF/actions/create-issue@2b8bc36af85b88bca0dd7bfac2e2dc05f94ad712
+        uses: XRPLF/actions/create-issue@fbcc16eb7f20dc3199eaf1aed0d3523a5ba9008c
         with:
           title: "Clang-tidy check failed"
           body_file: ${{ env.ISSUE_FILE }}

.github/workflows/reusable-package.yml

@@ -1,99 +0,0 @@
-# Build Linux packages (DEB and RPM) from pre-built binary artifacts.
-# Discovers which configurations to package from linux.json (os entries
-# with "package": true) and fans out one job per entry. Today only
-# linux/amd64 is emitted; the architecture is hardcoded both here
-# (runner) and in generate.py.
-name: Package
-
-on:
-  workflow_call:
-    inputs:
-      pkg_release:
-        description: "Package release number. Increment when repackaging the same executable."
-        required: false
-        type: string
-        default: "1"
-
-defaults:
-  run:
-    shell: bash
-
-env:
-  BUILD_DIR: build
-
-jobs:
-  generate-matrix:
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.generate.outputs.matrix }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
-        with:
-          python-version: 3.13
-
-      - name: Generate packaging matrix
-        id: generate
-        working-directory: .github/scripts/strategy-matrix
-        run: |
-          ./generate.py --packaging --config=linux.json >>"${GITHUB_OUTPUT}"
-
-  generate-version:
-    runs-on: ubuntu-latest
-    outputs:
-      version: ${{ steps.version.outputs.version }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          sparse-checkout: |
-            .github/actions/generate-version
-            src/libxrpl/protocol/BuildInfo.cpp
-      - name: Generate version
-        id: version
-        uses: ./.github/actions/generate-version
-
-  package:
-    needs: [generate-matrix, generate-version]
-    if: ${{ github.event.repository.visibility == 'public' }}
-    strategy:
-      fail-fast: false
-      matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
-    name: "${{ matrix.artifact_name }}"
-    permissions:
-      contents: read
-    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
-    container: ${{ format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-{4}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version, matrix.os.image_sha) }}
-    timeout-minutes: 30
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - name: Download pre-built binary
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          name: ${{ matrix.artifact_name }}
-          path: ${{ env.BUILD_DIR }}
-
-      - name: Make binary executable
-        run: chmod +x "${BUILD_DIR}/xrpld"
-
-      - name: Build package
-        env:
-          PKG_VERSION: ${{ needs.generate-version.outputs.version }}
-          PKG_RELEASE: ${{ inputs.pkg_release }}
-        run: ./package/build_pkg.sh
-
-      - name: Upload package artifact
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: ${{ matrix.artifact_name }}-pkg-${{ needs.generate-version.outputs.version }}
-          path: |
-            ${{ env.BUILD_DIR }}/debbuild/*.deb
-            ${{ env.BUILD_DIR }}/debbuild/*.ddeb
-            ${{ env.BUILD_DIR }}/rpmbuild/RPMS/**/*.rpm
-          if-no-files-found: error

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

@@ -42,4 +42,4 @@ jobs:
         env:
           GENERATE_CONFIG: ${{ inputs.os != '' && format('--config={0}.json', inputs.os) || '' }}
           GENERATE_OPTION: ${{ inputs.strategy_matrix == 'all' && '--all' || '' }}
-        run: ./generate.py ${GENERATE_OPTION} ${GENERATE_CONFIG} >>"${GITHUB_OUTPUT}"
+        run: ./generate.py ${GENERATE_OPTION} ${GENERATE_CONFIG} >> "${GITHUB_OUTPUT}"

.pre-commit-config.yaml

@@ -37,57 +37,40 @@ repos:
         exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_entries)/
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: dd18dad857d6133e90bbe478f4f2f22ec0030269 # frozen: v22.1.5
+    rev: cd481d7b0bfb5c7b3090c21846317f9a8262e891 # frozen: v22.1.0
     hooks:
       - id: clang-format
         args: [--style=file]
         "types_or": [c++, c, proto]
         exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_entries)/
 
-  - repo: https://github.com/BlankSpruce/gersemi-pre-commit
-    rev: faadd6a9d852369ca94f4d15b2404c967ba8cb01 # frozen: 0.27.6
+  - repo: https://github.com/BlankSpruce/gersemi
+    rev: 0.26.0
     hooks:
       - id: gersemi
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: 515f543f5718ebfd6ce22e16708bb32c68ff96e1 # frozen: v3.8.3
+    rev: c2bc67fe8f8f549cc489e00ba8b45aa18ee713b1 # frozen: v3.8.1
     hooks:
       - id: prettier
         args: [--end-of-line=auto]
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 4160603246a6b365d4a2af661c6d71b0a0f50478 # frozen: 26.5.1
+    rev: ea488cebbfd88a5f50b8bd95d5c829d0bb76feb8 # frozen: 26.1.0
     hooks:
       - id: black
 
-  - repo: https://github.com/scop/pre-commit-shfmt
-    rev: 05c1426671b9237fb5e1444dd63aa5731bec0dfb # frozen: v3.13.1-1
+  - repo: https://github.com/openstack/bashate
+    rev: 5798d24d571676fc407e81df574c1ef57b520f23 # frozen: 2.1.1
     hooks:
-      - id: shfmt
-        args: [--write, --indent=4, --case-indent=true]
-
-  - repo: local
-    hooks:
-      - id: format-inline-bash-workflows
-        name: "format `run:` blocks in workflows/actions"
-        entry: ./.github/scripts/format-inline-bash.py
-        language: python
-        files: ^\.github/(workflows|actions)/.*\.ya?ml$
-      - id: format-inline-bash-markdown
-        name: "format ```bash blocks in markdown"
-        entry: ./.github/scripts/format-inline-bash.py
-        language: python
-        files: \.md$
+      - id: bashate
+        args: ["--ignore=E006"]
 
   - repo: https://github.com/streetsidesoftware/cspell-cli
-    rev: 4643f154907327ee0a2c7038f0296e0dd77d9776 # frozen: v10.0.0
+    rev: a42085ade523f591dca134379a595e7859986445 # frozen: v9.7.0
     hooks:
       - id: cspell # Spell check changed files
-        exclude: |
-          (?x)^(
-              .config/cspell.config.yaml|
-              include/xrpl/protocol_autogen/(transactions|ledger_entries)/.*
-          )$
+        exclude: (.config/cspell.config.yaml|^include/xrpl/protocol_autogen/(transactions|ledger_entries)/)
       - id: cspell # Spell check the commit message
         name: check commit message spelling
         args:

BUILD.md

@@ -151,8 +151,8 @@ git init
 git remote add origin git@github.com:XRPLF/conan-center-index.git
 git sparse-checkout init
 for recipe in "${recipes[@]}"; do
-    echo "Checking out recipe '${recipe}'..."
-    git sparse-checkout add recipes/${recipe}
+  echo "Checking out recipe '${recipe}'..."
+  git sparse-checkout add recipes/${recipe}
 done
 git fetch origin master
 git checkout master
@@ -180,7 +180,7 @@ the new recipe will be automatically pulled from the official Conan Center.
 
 If you see an error similar to the following after running `conan profile show`:
 
-```text
+```bash
 ERROR: Invalid setting '17' is not a valid 'settings.compiler.version' value.
 Possible values are ['5.0', '5.1', '6.0', '6.1', '7.0', '7.3', '8.0', '8.1',
 '9.0', '9.1', '10.0', '11.0', '12.0', '13', '13.0', '13.1', '14', '14.0', '15',
@@ -427,19 +427,16 @@ install ccache --version 4.11.3 --allow-downgrade`.
    Single-config generators:
 
    ```
-   cmake --build . --parallel N
+   cmake --build .
    ```
 
    Multi-config generators:
 
    ```
-   cmake --build . --config Release --parallel N
-   cmake --build . --config Debug --parallel N
+   cmake --build . --config Release
+   cmake --build . --config Debug
    ```
 
-   Replace the `--parallel` parameter N with the desired number of parallel jobs. A common starting point is half of the number of available CPU
-   cores.
-
 5. Test xrpld.
 
    Single-config generators:

CMakeLists.txt

@@ -94,6 +94,7 @@ find_package(secp256k1 REQUIRED)
 find_package(SOCI REQUIRED)
 find_package(SQLite3 REQUIRED)
 find_package(xxHash REQUIRED)
+find_package(spdlog REQUIRED)
 
 target_link_libraries(
     xrpl_libs
@@ -134,7 +135,6 @@ endif()
 include(XrplCore)
 include(XrplProtocolAutogen)
 include(XrplInstall)
-include(XrplPackaging)
 include(XrplValidatorKeys)
 
 if(tests)

bin/git/setup-upstreams.sh

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

bin/git/squash-branches.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
 
 if [[ $# -lt 3 || "$1" == "--help" || "$1" = "-h" ]]; then
-    name=$(basename $0)
-    cat <<-USAGE
+    name=$( basename $0 )
+    cat <<- USAGE
     Usage: $name workbranch base/branch user/branch [user/branch [...]]
 
     * workbranch will be created locally from base/branch
@@ -16,7 +16,7 @@ fi
 work="$1"
 shift
 
-branches=($(echo "${@}" | sed "s/:/\//"))
+branches=( $( echo "${@}" | sed "s/:/\//" ) )
 base="${branches[0]}"
 unset branches[0]
 
@@ -24,10 +24,10 @@ set -e
 
 users=()
 for b in "${branches[@]}"; do
-    users+=($(echo $b | cut -d/ -f1))
+    users+=( $( echo $b | cut -d/ -f1 ) )
 done
 
-users=($(printf '%s\n' "${users[@]}" | sort -u))
+users=( $( printf '%s\n' "${users[@]}" | sort -u ) )
 
 git fetch --multiple upstreams "${users[@]}"
 git checkout -B "$work" --no-track "$base"
@@ -40,7 +40,7 @@ done
 # Make sure the commits look right
 git log --show-signature "$base..HEAD"
 
-parts=($(echo $base | sed "s/\// /"))
+parts=( $( echo $base | sed "s/\// /" ) )
 repo="${parts[0]}"
 b="${parts[1]}"
 push=$repo
@@ -50,7 +50,7 @@ fi
 if [[ "$repo" == "upstream" ]]; then
     repo="upstreams"
 fi
-cat <<PUSH
+cat << PUSH
 
 -------------------------------------------------------------------
 This script will not push. Verify everything is correct, then push

bin/git/update-version.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
 
 if [[ $# -ne 3 || "$1" == "--help" || "$1" = "-h" ]]; then
-    name=$(basename $0)
-    cat <<-USAGE
+    name=$( basename $0 )
+    cat <<- USAGE
     Usage: $name workbranch base/branch version
 
     * workbranch will be created locally from base/branch. If it exists,
@@ -16,7 +16,7 @@ fi
 work="$1"
 shift
 
-base=$(echo "$1" | sed "s/:/\//")
+base=$( echo "$1" | sed "s/:/\//" )
 shift
 
 version=$1
@@ -28,16 +28,16 @@ git fetch upstreams
 
 git checkout -B "${work}" --no-track "${base}"
 
-push=$(git rev-parse --abbrev-ref --symbolic-full-name '@{push}' \
-    2>/dev/null) || true
+push=$( git rev-parse --abbrev-ref --symbolic-full-name '@{push}' \
+    2>/dev/null ) || true
 if [[ "${push}" != "" ]]; then
     echo "Warning: ${push} may already exist."
 fi
 
-build=$(find -name BuildInfo.cpp)
-sed 's/\(^.*versionString =\).*$/\1 "'${version}'"/' ${build} >version.cpp &&
-    diff "${build}" version.cpp && exit 1 ||
-    mv -vi version.cpp ${build}
+build=$( find -name BuildInfo.cpp )
+sed 's/\(^.*versionString =\).*$/\1 "'${version}'"/' ${build} > version.cpp && \
+diff "${build}" version.cpp && exit 1 || \
+mv -vi version.cpp ${build}
 
 git diff
 
@@ -47,7 +47,7 @@ git commit -S -m "Set version to ${version}"
 
 git log --oneline --first-parent ${base}^..
 
-cat <<PUSH
+cat << PUSH
 
 -------------------------------------------------------------------
 This script will not push. Verify everything is correct, then push

bin/pre-commit/clang_tidy_check.py

@@ -168,13 +168,7 @@ def main():
     if not os.environ.get("TIDY"):
         return 0
 
-    repo_root = Path(
-        subprocess.check_output(
-            ["git", "rev-parse", "--show-toplevel"],
-            cwd=Path(__file__).parent,
-            text=True,
-        ).strip()
-    )
+    repo_root = Path(__file__).parent.parent
     files = staged_files(repo_root)
     if not files:
         return 0

cfg/validators-example.txt

@@ -28,7 +28,7 @@
 #    https://vl.ripple.com
 #    https://unl.xrplf.org
 #    http://127.0.0.1:8000
-#    file:///etc/xrpld/vl.txt
+#    file:///etc/opt/xrpld/vl.txt
 #
 # [validator_list_keys]
 #

cfg/xrpld-example.cfg

@@ -527,17 +527,6 @@
 #
 #       The current default (which is subject to change) is 300 seconds.
 #
-#   verify_endpoints = <0 | 1>
-#
-#       If set to 0, the server will skip validation of endpoint
-#       addresses received in TMEndpoints peer protocol messages,
-#       allowing addresses that are not publicly routable or have a
-#       port of 0. The default is 1 (verification enabled).
-#
-#       WARNING: Disabling this option is a security risk and should
-#       only be used for local testing and debugging. Do not disable
-#       on mainnet.
-#
 #
 # [transaction_queue] EXPERIMENTAL
 #
@@ -953,21 +942,6 @@
 #
 #   Optional keys for NuDB and RocksDB:
 #
-#       cache_size          Size of cache for database records. Default is 16384.
-#                           Setting this value to 0 will use the default value.
-#
-#       cache_age           Length of time in minutes to keep database records
-#                           cached. Default is 5 minutes. Setting this value to
-#                           0 will use the default value.
-#
-#                           Note: if cache_size or cache_age is not specified,
-#                           default values will be used for the unspecified
-#                           parameter.
-#
-#                           Note: the cache will not be created if online_delete
-#                           is specified, because the rotating NodeStore does
-#                           not use this cache).
-#
 #       fast_load           Boolean. If set, load the last persisted ledger
 #                           from disk upon process start before syncing to
 #                           the network. This is likely to improve performance
@@ -1481,7 +1455,10 @@ admin = 127.0.0.1
 protocol = http
 
 [port_peer]
-port = 2459
+# Many servers still use the legacy port of 51235, so for backward-compatibility
+# we maintain that port number here. However, for new servers we recommend
+# changing this to the default port of 2459.
+port = 51235
 ip = 0.0.0.0
 # alternatively, to accept connections on IPv4 + IPv6, use:
 #ip = ::

cmake/XrplCore.cmake

@@ -69,6 +69,7 @@ target_link_libraries(
         secp256k1::secp256k1
         xrpl.libpb
         xxHash::xxhash
+        spdlog::spdlog
         $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
 )
 

cmake/XrplPackaging.cmake

@@ -1,44 +0,0 @@
-#[===================================================================[
-   Linux packaging support: 'package' target.
-
-   The packaging script (package/build_pkg.sh) installs to FHS-standard
-   paths (/usr/bin, /etc/xrpld, etc.) regardless of CMAKE_INSTALL_PREFIX,
-   so no prefix guard is needed here.
-#]===================================================================]
-if(NOT is_linux)
-    message(STATUS "Packaging not supported on non-Linux hosts")
-    return()
-endif()
-
-if(NOT DEFINED pkg_release)
-    set(pkg_release 1)
-endif()
-
-find_program(RPMBUILD_EXECUTABLE rpmbuild)
-find_program(DPKG_BUILDPACKAGE_EXECUTABLE dpkg-buildpackage)
-
-if(NOT (RPMBUILD_EXECUTABLE OR DPKG_BUILDPACKAGE_EXECUTABLE))
-    message(
-        STATUS
-        "Neither rpmbuild nor dpkg-buildpackage found; 'package' target not available"
-    )
-    return()
-endif()
-
-set(package_env
-    SRC_DIR=${CMAKE_SOURCE_DIR}
-    BUILD_DIR=${CMAKE_BINARY_DIR}
-    PKG_VERSION=${xrpld_version}
-    PKG_RELEASE=${pkg_release}
-)
-
-add_custom_target(
-    package
-    COMMAND
-        ${CMAKE_COMMAND} -E env ${package_env}
-        ${CMAKE_SOURCE_DIR}/package/build_pkg.sh
-    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-    DEPENDS xrpld
-    COMMENT "Building Linux package (deb/rpm inferred from host tooling)"
-    VERBATIM
-)

cmake/scripts/codegen/requirements.in

@@ -1,13 +0,0 @@
-# Python dependencies for XRP Ledger code generation scripts
-#
-# These packages are required to run the code generation scripts that
-# parse macro files and generate C++ wrapper classes.
-
-# C preprocessor for Python - used to preprocess macro files
-pcpp>=1.30
-
-# Parser combinator library - used to parse the macro DSL
-pyparsing>=3.0.0
-
-# Template engine - used to generate C++ code from templates
-Mako>=1.2.2

cmake/scripts/codegen/requirements.txt

@@ -1,105 +1,13 @@
-# This file was autogenerated by uv via the following command:
-#    uv pip compile requirements.in --generate-hashes --output-file requirements.txt
-mako==1.3.12 \
-    --hash=sha256:8f61569480282dbf557145ce441e4ba888be453c30989f879f0d652e39f53ea9 \
-    --hash=sha256:9f778e93289bd410bb35daadeb4fc66d95a746f0b75777b942088b7fd7af550a
-    # via -r requirements.in
-markupsafe==3.0.3 \
-    --hash=sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f \
-    --hash=sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a \
-    --hash=sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf \
-    --hash=sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19 \
-    --hash=sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf \
-    --hash=sha256:0f4b68347f8c5eab4a13419215bdfd7f8c9b19f2b25520968adfad23eb0ce60c \
-    --hash=sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175 \
-    --hash=sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219 \
-    --hash=sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb \
-    --hash=sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6 \
-    --hash=sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab \
-    --hash=sha256:15d939a21d546304880945ca1ecb8a039db6b4dc49b2c5a400387cdae6a62e26 \
-    --hash=sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1 \
-    --hash=sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce \
-    --hash=sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218 \
-    --hash=sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634 \
-    --hash=sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695 \
-    --hash=sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad \
-    --hash=sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73 \
-    --hash=sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c \
-    --hash=sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe \
-    --hash=sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa \
-    --hash=sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559 \
-    --hash=sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa \
-    --hash=sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37 \
-    --hash=sha256:3537e01efc9d4dccdf77221fb1cb3b8e1a38d5428920e0657ce299b20324d758 \
-    --hash=sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f \
-    --hash=sha256:38664109c14ffc9e7437e86b4dceb442b0096dfe3541d7864d9cbe1da4cf36c8 \
-    --hash=sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d \
-    --hash=sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c \
-    --hash=sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97 \
-    --hash=sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a \
-    --hash=sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19 \
-    --hash=sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9 \
-    --hash=sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9 \
-    --hash=sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc \
-    --hash=sha256:591ae9f2a647529ca990bc681daebdd52c8791ff06c2bfa05b65163e28102ef2 \
-    --hash=sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4 \
-    --hash=sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354 \
-    --hash=sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50 \
-    --hash=sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698 \
-    --hash=sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9 \
-    --hash=sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b \
-    --hash=sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc \
-    --hash=sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115 \
-    --hash=sha256:7c3fb7d25180895632e5d3148dbdc29ea38ccb7fd210aa27acbd1201a1902c6e \
-    --hash=sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485 \
-    --hash=sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f \
-    --hash=sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12 \
-    --hash=sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025 \
-    --hash=sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009 \
-    --hash=sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d \
-    --hash=sha256:949b8d66bc381ee8b007cd945914c721d9aba8e27f71959d750a46f7c282b20b \
-    --hash=sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a \
-    --hash=sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5 \
-    --hash=sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f \
-    --hash=sha256:a320721ab5a1aba0a233739394eb907f8c8da5c98c9181d1161e77a0c8e36f2d \
-    --hash=sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1 \
-    --hash=sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287 \
-    --hash=sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6 \
-    --hash=sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f \
-    --hash=sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581 \
-    --hash=sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed \
-    --hash=sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b \
-    --hash=sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c \
-    --hash=sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026 \
-    --hash=sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8 \
-    --hash=sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676 \
-    --hash=sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6 \
-    --hash=sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e \
-    --hash=sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d \
-    --hash=sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d \
-    --hash=sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01 \
-    --hash=sha256:df2449253ef108a379b8b5d6b43f4b1a8e81a061d6537becd5582fba5f9196d7 \
-    --hash=sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419 \
-    --hash=sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795 \
-    --hash=sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1 \
-    --hash=sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5 \
-    --hash=sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d \
-    --hash=sha256:e8fc20152abba6b83724d7ff268c249fa196d8259ff481f3b1476383f8f24e42 \
-    --hash=sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe \
-    --hash=sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda \
-    --hash=sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e \
-    --hash=sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737 \
-    --hash=sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523 \
-    --hash=sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591 \
-    --hash=sha256:f71a396b3bf33ecaa1626c255855702aca4d3d9fea5e051b41ac59a9c1c41edc \
-    --hash=sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a \
-    --hash=sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50
-    # via mako
-pcpp==1.30 \
-    --hash=sha256:05fe08292b6da57f385001c891a87f40d6aa7f46787b03e8ba326d20a3297c6e \
-    --hash=sha256:5af9fbce55f136d7931ae915fae03c34030a3b36c496e72d9636cedc8e2543a1
-    # via -r requirements.in
-pyparsing==3.3.2 \
-    --hash=sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d \
-    --hash=sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc
-    # via -r requirements.in
+# Python dependencies for XRP Ledger code generation scripts
+#
+# These packages are required to run the code generation scripts that
+# parse macro files and generate C++ wrapper classes.
+
+# C preprocessor for Python - used to preprocess macro files
+pcpp>=1.30
+
+# Parser combinator library - used to parse the macro DSL
+pyparsing>=3.0.0
+
+# Template engine - used to generate C++ code from templates
+Mako>=1.2.0

cmake/scripts/codegen/templates/LedgerEntry.h.mako

@@ -33,7 +33,7 @@ public:
      * @brief Construct a ${name} ledger entry wrapper from an existing SLE object.
      * @throws std::runtime_error if the ledger entry type doesn't match.
      */
-    explicit ${name}(SLE::const_pointer sle)
+    explicit ${name}(std::shared_ptr<SLE const> sle)
         : LedgerEntryBase(std::move(sle))
     {
         // Verify ledger entry type
@@ -168,7 +168,7 @@ ${field['typeData']['setter_type']} ${field['paramName']}${',' if i < len(requir
      * @param sle The existing ledger entry to copy from.
      * @throws std::runtime_error if the ledger entry type doesn't match.
      */
-    ${name}Builder(SLE::const_pointer sle)
+    ${name}Builder(std::shared_ptr<SLE const> sle)
     {
         if (sle->at(sfLedgerEntryType) != ${tag})
         {

conan.lock

@@ -1,9 +1,10 @@
 {
     "version": "0.5",
     "requires": [
-        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1777558780.503",
+        "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809",
         "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987",
-        "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1776096494.149",
+        "sqlite3/3.51.0#66aa11eabd0e34954c5c1c061ad44abe%1774467355.988",
+        "spdlog/1.17.0#bcbaaf7147bda6ad24ffbd1ac3d7142c%1768312128.781",
         "soci/4.0.3#fe32b9ad5eb47e79ab9e45a68f363945%1774450067.231",
         "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1765850147.878",
         "secp256k1/0.7.1#481881709eb0bdd0185a12b912bbe8ad%1770910500.329",
@@ -15,19 +16,20 @@
         "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914",
         "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1765842973.492",
         "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1765842973.03",
-        "libarchive/3.8.7#c446109bd1f1d8ba7936c94189bc50e6%1776147552.838",
-        "jemalloc/5.3.1#1fc58d55316041f10fbc1e8a2eae632a%1776700028.228",
+        "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1765850144.736",
+        "jemalloc/5.3.0#c671e612af76700db5957c9857978a1c%1776700030.961",
         "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1768312129.152",
         "grpc/1.78.1#b1a9e74b145cc471bed4dc64dc6eb2c1%1774467387.342",
+        "fmt/12.1.0#50abab23274d56bb8f42c94b3b9a40c7%1763984116.926",
         "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1765850143.772",
         "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1765850143.772",
         "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1774439234.681",
         "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837",
-        "boost/1.91.0#ea540ca2133d831b560036aa24dece3c%1778050991.9",
+        "boost/1.90.0#d5e8defe7355494953be18524a7f135b%1769454080.269",
         "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196"
     ],
     "build_requires": [
-        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1777558780.503",
+        "zlib/1.3.1#cac0f6daea041b0ccf42934163defb20%1774439233.809",
         "strawberryperl/5.32.1.1#8d114504d172cfea8ea1662d09b6333e%1774447376.964",
         "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12",
         "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1765850144.707",
@@ -48,13 +50,13 @@
             "lz4/1.10.0"
         ],
         "boost/[>=1.83.0 <1.91.0]": [
-            "boost/1.91.0"
+            "boost/1.90.0"
         ],
         "sqlite3/[>=3.44 <4]": [
-            "sqlite3/3.53.0"
+            "sqlite3/3.51.0"
         ],
         "boost/1.83.0": [
-            "boost/1.91.0"
+            "boost/1.90.0"
         ],
         "lz4/[>=1.9.4 <2]": [
             "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504"

conan/global.conf

@@ -3,5 +3,3 @@
 core:non_interactive=True
 core.download:parallel={{ os.cpu_count() }}
 core.upload:parallel={{ os.cpu_count() }}
-tools.files.download:retry=5
-tools.files.download:retry_wait=10

conanfile.py

@@ -1,3 +1,4 @@
+import os
 import re
 
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
@@ -29,12 +30,13 @@ class Xrpl(ConanFile):
     requires = [
         "ed25519/2015.03",
         "grpc/1.78.1",
-        "libarchive/3.8.7",
+        "libarchive/3.8.1",
         "nudb/2.0.9",
         "openssl/3.6.2",
         "secp256k1/0.7.1",
         "soci/4.0.3",
-        "zlib/1.3.2",
+        "spdlog/1.17.0",
+        "zlib/1.3.1",
     ]
 
     test_requires = [
@@ -56,7 +58,6 @@ class Xrpl(ConanFile):
         "tests": False,
         "unity": False,
         "xrpld": False,
-        "boost/*:without_cobalt": True,
         "boost/*:without_context": False,
         "boost/*:without_coroutine": True,
         "boost/*:without_coroutine2": False,
@@ -109,6 +110,7 @@ class Xrpl(ConanFile):
         "secp256k1/*:shared": False,
         "snappy/*:shared": False,
         "soci/*:shared": False,
+        "spdlog/*:shared": False,
         "soci/*:with_sqlite3": True,
         "soci/*:with_boost": True,
         "xxhash/*:shared": False,
@@ -130,13 +132,13 @@ class Xrpl(ConanFile):
             self.options["boost"].without_cobalt = True
 
     def requirements(self):
-        self.requires("boost/1.91.0", force=True, transitive_headers=True)
+        self.requires("boost/1.90.0", force=True, transitive_headers=True)
         self.requires("date/3.0.4", transitive_headers=True)
         self.requires("lz4/1.10.0", force=True)
         self.requires("protobuf/6.33.5", force=True)
-        self.requires("sqlite3/3.53.0", force=True)
+        self.requires("sqlite3/3.51.0", force=True)
         if self.options.jemalloc:
-            self.requires("jemalloc/5.3.1")
+            self.requires("jemalloc/5.3.0")
         if self.options.rocksdb:
             self.requires("rocksdb/10.5.1")
         self.requires("xxhash/0.8.3", transitive_headers=True)
@@ -213,6 +215,7 @@ class Xrpl(ConanFile):
             "protobuf::libprotobuf",
             "soci::soci",
             "secp256k1::secp256k1",
+            "spdlog::spdlog",
             "sqlite3::sqlite",
             "xxhash::xxhash",
             "zlib::zlib",

cspell.config.yaml

@@ -63,7 +63,6 @@ words:
   - Bougalis
   - Britto
   - Btrfs
-  - Buildx
   - canonicality
   - changespq
   - checkme
@@ -93,22 +92,18 @@ words:
   - daria
   - dcmake
   - dearmor
-  - dedented
   - deleteme
   - demultiplexer
   - deserializaton
   - desync
   - desynced
   - determ
-  - disablerepo
   - distro
   - doxyfile
   - dxrpl
   - enabled
-  - enablerepo
   - endmacro
   - exceptioned
-  - EXPECT_STREQ
   - Falco
   - fcontext
   - finalizers
@@ -166,7 +161,6 @@ words:
   - Merkle
   - Metafuncton
   - misprediction
-  - missingok
   - mptbalance
   - MPTDEX
   - mptflags
@@ -198,15 +192,11 @@ words:
   - NOLINT
   - NOLINTNEXTLINE
   - nonxrp
-  - noreplace
   - noripple
-  - nostdinc
-  - notifempty
   - nudb
   - nullptr
   - nunl
   - Nyffenegger
-  - onlatest
   - ostr
   - pargs
   - partitioner
@@ -222,7 +212,6 @@ words:
   - preauthorize
   - preauthorizes
   - preclaim
-  - preun
   - protobuf
   - protos
   - ptrs
@@ -257,15 +246,12 @@ words:
   - sfields
   - shamap
   - shamapitem
-  - shfmt
-  - shlibs
   - sidechain
   - SIGGOOD
   - sle
   - sles
   - soci
   - socidb
-  - SRPMS
   - sslws
   - statsd
   - STATSDCOLLECTOR
@@ -293,8 +279,8 @@ words:
   - txn
   - txns
   - txs
-  - ubsan
   - UBSAN
+  - ubsan
   - umant
   - unacquired
   - unambiguity
@@ -302,7 +288,6 @@ words:
   - unauthorizing
   - unergonomic
   - unfetched
-  - unfindable
   - unflatten
   - unfund
   - unimpair
@@ -332,6 +317,7 @@ words:
   - xbridge
   - xchain
   - ximinez
+  - EXPECT_STREQ
   - XMACRO
   - xrpkuwait
   - xrpl
@@ -339,4 +325,3 @@ words:
   - xrplf
   - xxhash
   - xxhasher
-  - CGNAT

docker/check-tool-versions.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-# Verify that every tool expected in the Nix CI env is present and runnable.
-set -euo pipefail
-
-ccache --version
-clang --version
-clang++ --version
-clang-format --version
-cmake --version
-conan --version
-g++ --version
-gcc --version
-gcovr --version
-git --version
-less --version
-make --version
-mold --version
-ninja --version
-perl --version
-pkg-config --version
-pre-commit --version
-python3 --version
-run-clang-tidy --help
-vim --version

docker/install-sanitizer-libs.sh

@@ -1,89 +0,0 @@
-#!/bin/bash
-# Install sanitizer runtime libraries required to run binaries compiled with:
-#   -fsanitize=address   → libasan.so.8
-#   -fsanitize=thread    → libtsan.so.2
-#   -fsanitize=undefined → libubsan.so.1
-#
-# The exact SONAMEs required depend on the compiler toolchain used to build the
-# test binaries (see nix/ci-env.nix). If the toolchain is bumped and SONAMEs
-# change, update the list below (or detect them from the binaries).
-#
-# Supported base images:
-#   debian:bookworm
-#   ubuntu:20.04
-#   rhel:9
-#   nixos/nix        — tests are skipped; this script is not called
-
-set -euo pipefail
-
-if [ ! -f /etc/os-release ]; then
-    echo "ERROR: /etc/os-release not found; cannot detect OS" >&2
-    exit 1
-fi
-
-# shellcheck source=/dev/null
-. /etc/os-release
-
-echo "Detected OS: ${ID} ${VERSION_ID:-}"
-
-case "${ID}" in
-    debian)
-        apt-get update -y
-        apt-get install -y --no-install-recommends \
-            libasan8 \
-            libtsan2 \
-            libubsan1
-
-        apt-get clean
-        rm -rf /var/lib/apt/lists/*
-        ;;
-
-    ubuntu)
-        apt-get update -y
-        apt-get install -y --no-install-recommends \
-            gnupg \
-            software-properties-common
-        add-apt-repository -y ppa:ubuntu-toolchain-r/test
-        apt-get update -y
-        apt-get install -y --no-install-recommends \
-            libasan8 \
-            libtsan2 \
-            libubsan1
-
-        apt-get clean
-        rm -rf /var/lib/apt/lists/*
-        ;;
-
-    rhel | centos | rocky | almalinux)
-        dnf install -y \
-            libasan8 \
-            libtsan2 \
-            libubsan
-
-        dnf clean -y all
-        rm -rf /var/cache/dnf/*
-        ;;
-
-    *)
-        echo "ERROR: unsupported OS '${ID}'. Supported: debian, ubuntu, rhel-family" >&2
-        exit 1
-        ;;
-esac
-
-# Verify that every expected library is now resolvable by the dynamic linker.
-missing=0
-for lib in libasan.so.8 libtsan.so.2 libubsan.so.1; do
-    if ldconfig -p | grep -q "${lib}"; then
-        echo "OK: ${lib} found"
-    else
-        echo "ERROR: ${lib} not found after installation" >&2
-        missing=$((missing + 1))
-    fi
-done
-
-if [ "${missing}" -ne 0 ]; then
-    echo "ERROR: ${missing} library/libraries missing" >&2
-    exit 1
-fi
-
-echo "All sanitizer runtime libraries installed successfully."

docker/loader-path.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-case "$(uname -m)" in
-    x86_64) LOADER=/lib64/ld-linux-x86-64.so.2 ;;
-    aarch64) LOADER=/lib/ld-linux-aarch64.so.1 ;;
-    *)
-        echo "Unsupported arch: $(uname -m)" >&2
-        exit 1
-        ;;
-esac
-
-echo "${LOADER}"

docker/nix.Dockerfile

@@ -1,108 +0,0 @@
-ARG BASE_IMAGE=nixos/nix:latest
-
-# Nix builder
-FROM nixos/nix:latest AS builder-source
-
-RUN mkdir -p ~/.config/nix && \
-    echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
-
-# Copy our source and setup our working dir.
-COPY nix/ci-env.nix /tmp/build/nix/ci-env.nix
-COPY nix/packages.nix /tmp/build/nix/packages.nix
-COPY nix/utils.nix /tmp/build/nix/utils.nix
-COPY flake.nix /tmp/build/
-COPY flake.lock /tmp/build/
-WORKDIR /tmp/build
-
-FROM builder-source AS builder
-
-# Build our Nix CI environment (all build tools in a single store path)
-RUN nix \
-    --option filter-syscalls false \
-    build
-
-# Copy the Nix store closure into a directory. The Nix store closure is the
-# entire set of Nix store values that we need for our build.
-RUN mkdir /tmp/nix-store-closure && \
-    cp -R $(nix-store -qR result/) /tmp/nix-store-closure
-
-# Final image
-FROM ${BASE_IMAGE} AS final
-
-ARG BASE_IMAGE
-
-# bash is not located at /bin/bash in nixos/nix, so we need to create a symlink to it.
-RUN if echo "${BASE_IMAGE}" | grep -qiE 'nixos'; then \
-        ln -s /root/.nix-profile/bin/bash /bin/bash; \
-    fi
-
-# Use Bash as the default shell for RUN commands, using the options
-# `set -o errexit -o pipefail`, and as the entrypoint.
-SHELL ["/bin/bash", "-e", "-o", "pipefail", "-c"]
-ENTRYPOINT ["/bin/bash"]
-
-# Copy /nix/store and the env symlink tree
-COPY --from=builder /tmp/nix-store-closure /nix/store
-COPY --from=builder /tmp/build/result /nix/ci-env
-
-ENV PATH="/nix/ci-env/bin:${PATH}"
-
-# Externally-built dynamically-linked ELF binaries hard-code the loader path
-# (e.g. /lib64/ld-linux-x86-64.so.2) in their PT_INTERP header. Install it
-# from the Nix store when the base image doesn't already provide one.
-COPY docker/loader-path.sh /tmp/loader-path.sh
-
-RUN <<EOF
-target="$(/tmp/loader-path.sh)"
-
-if [ ! -e "${target}" ]; then
-    # Use the loader from the same glibc that gcc links libc against, so
-    # ld-linux and libc/libpthread share GLIBC_PRIVATE symbols at runtime.
-    src="$(dirname "$(gcc -print-file-name=libc.so.6)")/$(basename "${target}")"
-    [ -e "${src}" ] || { echo "ld-linux not found at ${src}" >&2; exit 1; }
-    mkdir -p "$(dirname "${target}")"
-    cp "${src}" "${target}"
-fi
-EOF
-
-COPY docker/check-tool-versions.sh /tmp/check-tool-versions.sh
-RUN /tmp/check-tool-versions.sh
-
-# Sanity-check that the g++/clang++ are able to build binaries, including sanitizer-instrumented ones.
-COPY docker/test_files/cpp_sources/ /tmp/cpp_sources/
-COPY docker/test_files/compile-cpp-sources.sh /tmp/compile-cpp-sources.sh
-RUN /tmp/compile-cpp-sources.sh /tmp/cpp_sources /tmp/bins
-
-# Tester: start from a clean BASE_IMAGE, install sanitizer runtime libraries,
-# and run the compiled test binaries to verify they execute correctly.
-FROM ${BASE_IMAGE} AS tester
-
-ARG BASE_IMAGE
-
-# bash is not located at /bin/bash in nixos/nix, so we need to create a symlink to it.
-RUN if echo "${BASE_IMAGE}" | grep -qiE 'nixos'; then \
-        ln -s /root/.nix-profile/bin/bash /bin/bash; \
-    fi
-
-SHELL ["/bin/bash", "-e", "-o", "pipefail", "-c"]
-
-# Sanity-check that the built binaries run correctly in the vanilla base image, with the necessary sanitizer runtime libraries installed.
-COPY docker/install-sanitizer-libs.sh /tmp/install-sanitizer-libs.sh
-COPY docker/test_files/run-test-binaries.sh /tmp/run-test-binaries.sh
-COPY --from=final /tmp/bins /tmp/bins
-
-RUN <<EOF
-if echo "${BASE_IMAGE}" | grep -qiE 'nixos'; then
-    echo "Skipping runnning binaries on NixOS."
-else
-    /tmp/install-sanitizer-libs.sh
-    /tmp/run-test-binaries.sh /tmp/bins
-fi
-touch /tmp/tests-passed
-EOF
-
-# Output: the final image, gated on a successful test run in the tester stage.
-# Copying the sentinel from tester creates a hard build dependency: if the test
-# run above failed, this stage — and the overall build — fails too.
-FROM final
-COPY --from=tester /tmp/tests-passed /tmp/tests-passed

docker/test_files/compile-cpp-sources.sh

@@ -1,57 +0,0 @@
-#!/bin/bash
-# Compile all C++ test binaries during the Docker image build.
-# Each binary has the target system's ELF PT_INTERP (dynamic-linker path)
-# baked in so it can run on the (potentially minimal) final BASE_IMAGE.
-
-set -eo pipefail
-
-src_dir="${1:?usage: $0 <src_dir> <dst_dir>}"
-dst_dir="${2:?usage: $0 <src_dir> <dst_dir>}"
-
-loader="$(/tmp/loader-path.sh)"
-
-mkdir -p "${dst_dir}"
-
-function compile() {
-    local compiler="${1}"
-    local name="${2}"
-    local san_flag="${3:-}"
-
-    local src="${src_dir}/${name}.cpp"
-    local binary="${dst_dir}/${name}-${compiler}"
-
-    echo "=== Compiling ${name} with ${compiler} ==="
-    # Always statically link libstdc++ so the test binary does not depend on
-    # the host's libstdc++.so.6 version.
-    local compile_cmd="${compiler} -std=c++23 -O1 -g \
-        -pthread \
-        -static-libstdc++ \
-        ${san_flag} \
-        ${src} -o ${binary}"
-    echo "Compile cmd: ${compile_cmd}"
-    eval "${compile_cmd}"
-
-    echo "=== Patching ${binary} to use ${loader} as PT_INTERP ==="
-    local patch_cmd="patchelf --set-interpreter ${loader} --remove-rpath ${binary}"
-    echo "Patch cmd: ${patch_cmd}"
-    eval "${patch_cmd}"
-}
-
-declare -A sanitize=(
-    [regular]=""
-
-    [asan]="-fsanitize=address"
-    [tsan]="-fsanitize=thread"
-    [ubsan]="-fsanitize=undefined -fno-sanitize-recover=all"
-)
-
-for name in regular asan tsan ubsan; do
-    san_flag="${sanitize[${name}]}"
-    for compiler in g++ clang++; do
-        compile "${compiler}" "${name}" "${san_flag}"
-    done
-done
-
-echo "=== All binaries compiled ==="
-
-ls -la "${dst_dir}"

docker/test_files/cpp_sources/asan.cpp

@@ -1,28 +0,0 @@
-#include <atomic>
-#include <cstddef>
-#include <iostream>
-
-#if defined(__clang__) || defined(__GNUC__)
-__attribute__((noinline))
-#elif defined(_MSC_VER)
-__declspec(noinline)
-#endif
-int
-read_after_free(volatile int* array, std::size_t index)
-{
-    std::atomic_signal_fence(std::memory_order_seq_cst);
-    int value = array[index];
-    std::atomic_signal_fence(std::memory_order_seq_cst);
-    return value;
-}
-
-int
-main()
-{
-    int* array = new int[5]{10, 20, 30, 40, 50};
-    delete[] array;
-
-    std::cout << "Value at index 2: " << read_after_free(array, 2) << std::endl;
-
-    return 0;
-}

docker/test_files/cpp_sources/regular.cpp

@@ -1,28 +0,0 @@
-#include <iostream>
-#include <mutex>
-#include <thread>
-#include <vector>
-
-static std::mutex gMutex;
-
-void
-worker(int id)
-{
-    std::lock_guard<std::mutex> lock(gMutex);
-    std::cout << "Hello from thread " << id << "\n";
-}
-
-int
-main()
-{
-    constexpr int kNumThreads = 10;
-    std::vector<std::thread> threads;
-    threads.reserve(kNumThreads);
-    for (int i = 0; i < kNumThreads; ++i)
-        threads.emplace_back(worker, i);
-    for (auto& t : threads)
-        t.join();
-
-    std::cout << "Hello from main thread\n";
-    return 0;
-}

docker/test_files/cpp_sources/tsan.cpp

@@ -1,26 +0,0 @@
-#include <iostream>
-#include <thread>
-
-static int kCounter = 0;
-
-void
-increment()
-{
-    for (int i = 0; i < 100'000; ++i)
-    {
-        ++kCounter;
-    }
-}
-
-int
-main()
-{
-    std::thread t1(increment);
-    std::thread t2(increment);
-
-    t1.join();
-    t2.join();
-
-    std::cout << "Final counter value: " << kCounter << std::endl;
-    return 0;
-}

docker/test_files/cpp_sources/ubsan.cpp

@@ -1,13 +0,0 @@
-#include <iostream>
-#include <limits>
-
-int
-main()
-{
-    int maxInt = std::numeric_limits<int>::max();
-    int volatile one = 1;
-    std::cout << "Current max: " << maxInt << std::endl;
-    int overflowed = maxInt + one;
-    std::cout << "Overflowed result: " << overflowed << std::endl;
-    return 0;
-}

docker/test_files/run-test-binaries.sh

@@ -1,86 +0,0 @@
-#!/bin/bash
-# Run pre-compiled sanitizer binaries and confirm each emits its expected diagnostic.
-# Binaries must already exist in <bins_dir> with the layout:
-# <name>-g++ and <name>-clang++ for name in {regular,asan,tsan,ubsan}
-
-set -eo pipefail
-
-bins_dir="${1:?usage: $0 <bins_dir>}"
-
-failed_binaries=()
-
-# Run a binary and verify its exit code and output.
-# Usage: run <binary> <expected_output> <expected_rc>
-function run() {
-    local binary="${1}"
-    local expected_output="${2}"
-    local expected_rc="${3}"
-
-    local out_file
-    out_file="$(mktemp)"
-
-    echo "=== Run ${binary} ==="
-    set +e
-    "${binary}" >"${out_file}" 2>&1
-    local rc=$?
-    set -e
-
-    cat "${out_file}"
-
-    local failed=0
-    if [ "${expected_rc}" = "nonzero" ]; then
-        if [ "${rc}" -eq 0 ]; then
-            echo "ERROR: expected non-zero exit code from ${binary}, got ${rc}" >&2
-            failed=1
-        fi
-    elif [ "${rc}" -ne "${expected_rc}" ]; then
-        echo "ERROR: expected exit code ${expected_rc} from ${binary}, got ${rc}" >&2
-        failed=1
-    fi
-
-    if ! grep -q "${expected_output}" "${out_file}"; then
-        echo "ERROR: expected '${expected_output}' from ${binary}" >&2
-        failed=1
-    fi
-
-    if [ "${failed}" -eq 0 ]; then
-        echo "OK: '${expected_output}' detected"
-    else
-        failed_binaries+=("${binary}")
-    fi
-}
-
-declare -A expect=(
-    [regular]="Hello from main thread"
-
-    [asan]="heap-use-after-free"
-    [tsan]="data race"
-    [ubsan]="signed integer overflow"
-)
-
-for compiler in g++ clang++; do
-    for name in regular asan tsan ubsan; do
-        binary="${bins_dir}/${name}-${compiler}"
-
-        if [ "${name}" = "tsan" ] && [ "${compiler}" = "g++" ] &&
-            grep -qi 'debian' /etc/os-release 2>/dev/null &&
-            [ "$(uname -m)" = "aarch64" ]; then
-            echo "=== Skipping ${binary} (tsan-g++ unsupported on Debian ARM64) ==="
-            echo "    NOTE: to enable it, add --security-opt seccomp=unconfined to your docker run command"
-            continue
-        fi
-
-        if [ "${name}" = "regular" ]; then
-            expected_rc=0
-        else
-            expected_rc=nonzero
-        fi
-        run "${binary}" "${expect[$name]}" "${expected_rc}"
-    done
-done
-
-if [ "${#failed_binaries[@]}" -gt 0 ]; then
-    echo "ERROR: the following binaries failed:" >&2
-    printf '  %s\n' "${failed_binaries[@]}" >&2
-    exit 1
-fi

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1777954456,
-        "narHash": "sha256-hGdgeU2Nk87RAuZyYjyDjFL6LK7dAZN5RE9+hrDTkDU=",
+        "lastModified": 1769461804,
+        "narHash": "sha256-6h5sROT/3CTHvzPy9koKBmoCa2eJKh4fzQK8eYFEgl8=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "549bd84d6279f9852cae6225e372cc67fb91a4c1",
+        "rev": "b579d443b37c9c5373044201ea77604e37e748c8",
         "type": "github"
       },
       "original": {
@@ -15,27 +15,9 @@
         "type": "indirect"
       }
     },
-    "nixpkgs-custom-glibc": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1593520194,
-        "narHash": "sha256-+TZW+2I7kLL9JglPNOagm1ywjf9ua0JYGoptq/dzVn0=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "9cd98386a38891d1074fc18036b842dc4416f562",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "9cd98386a38891d1074fc18036b842dc4416f562",
-        "type": "github"
-      }
-    },
     "root": {
       "inputs": {
-        "nixpkgs": "nixpkgs",
-        "nixpkgs-custom-glibc": "nixpkgs-custom-glibc"
+        "nixpkgs": "nixpkgs"
       }
     }
   },

flake.nix

@@ -2,24 +2,15 @@
   description = "Nix related things for xrpld";
   inputs = {
     nixpkgs.url = "nixpkgs/nixos-unstable";
-    # nixpkgs snapshot (2020-06-30) that shipped glibc 2.31 as the primary
-    # version — matches the system libc on Ubuntu 20.04 LTS. Imported
-    # manually (flake = false) because this revision predates nixpkgs'
-    # own flake.nix.
-    nixpkgs-custom-glibc = {
-      url = "github:NixOS/nixpkgs/9cd98386a38891d1074fc18036b842dc4416f562";
-      flake = false;
-    };
   };
 
   outputs =
-    { nixpkgs, nixpkgs-custom-glibc, ... }:
+    { nixpkgs, ... }:
     let
-      forEachSystem = import ./nix/utils.nix { inherit nixpkgs nixpkgs-custom-glibc; };
+      forEachSystem = (import ./nix/utils.nix { inherit nixpkgs; }).forEachSystem;
     in
     {
       devShells = forEachSystem (import ./nix/devshell.nix);
-      packages = forEachSystem (import ./nix/ci-env.nix);
       formatter = forEachSystem ({ pkgs, ... }: pkgs.nixfmt);
     };
 }

include/xrpl/basics/Expected.h

@@ -148,23 +148,17 @@ public:
     }
 
     [[nodiscard]] constexpr E const&
-    error() const&
+    error() const
     {
         return Base::error();
     }
 
-    [[nodiscard]] constexpr E&
-    error() &
+    constexpr E&
+    error()
     {
         return Base::error();
     }
 
-    [[nodiscard]] constexpr E&&
-    error() &&
-    {
-        return std::move(Base::error());
-    }
-
     constexpr explicit
     operator bool() const
     {
@@ -221,23 +215,17 @@ public:
     }
 
     [[nodiscard]] constexpr E const&
-    error() const&
+    error() const
     {
         return Base::error();
     }
 
-    [[nodiscard]] constexpr E&
-    error() &
+    constexpr E&
+    error()
     {
         return Base::error();
     }
 
-    [[nodiscard]] constexpr E&&
-    error() &&
-    {
-        return std::move(Base::error());
-    }
-
     constexpr explicit
     operator bool() const
     {

include/xrpl/basics/IntrusivePointer.h

@@ -406,8 +406,8 @@ private:
     // pointer. The low bit must be masked to zero when converting back to a
     // pointer. If the low bit is '1', this is a weak pointer.
     std::uintptr_t tp_{0};
-    static constexpr std::uintptr_t kTagMask = 1;
-    static constexpr std::uintptr_t kPtrMask = ~kTagMask;
+    static constexpr std::uintptr_t kTAG_MASK = 1;
+    static constexpr std::uintptr_t kPTR_MASK = ~kTAG_MASK;
 
 private:
     /** Return the raw pointer held by this object.

include/xrpl/basics/IntrusivePointer.ipp

@@ -567,14 +567,14 @@ template <class T>
 bool
 SharedWeakUnion<T>::isStrong() const
 {
-    return (tp_ & kTagMask) == 0u;
+    return (tp_ & kTAG_MASK) == 0u;
 }
 
 template <class T>
 bool
 SharedWeakUnion<T>::isWeak() const
 {
-    return (tp_ & kTagMask) != 0u;
+    return (tp_ & kTAG_MASK) != 0u;
 }
 
 template <class T>
@@ -641,7 +641,7 @@ template <class T>
 T*
 SharedWeakUnion<T>::unsafeGetRawPtr() const
 {
-    return reinterpret_cast<T*>(tp_ & kPtrMask);
+    return reinterpret_cast<T*>(tp_ & kPTR_MASK);
 }
 
 template <class T>
@@ -650,7 +650,7 @@ SharedWeakUnion<T>::unsafeSetRawPtr(T* p, RefStrength rs)
 {
     tp_ = reinterpret_cast<std::uintptr_t>(p);
     if (tp_ && rs == RefStrength::Weak)
-        tp_ |= kTagMask;
+        tp_ |= kTAG_MASK;
 }
 
 template <class T>

include/xrpl/basics/IntrusiveRefCounts.h

@@ -98,11 +98,11 @@ private:
     // enough for strong pointers and 14 bit counts are enough for weak
     // pointers. Use type aliases to make it easy to switch types.
     using CountType = std::uint16_t;
-    static constexpr size_t kStrongCountNumBits = sizeof(CountType) * 8;
-    static constexpr size_t kWeakCountNumBits = kStrongCountNumBits - 2;
+    static constexpr size_t kSTRONG_COUNT_NUM_BITS = sizeof(CountType) * 8;
+    static constexpr size_t kWEAK_COUNT_NUM_BITS = kSTRONG_COUNT_NUM_BITS - 2;
     using FieldType = std::uint32_t;
-    static constexpr size_t kFieldTypeBits = sizeof(FieldType) * 8;
-    static constexpr FieldType kOne = 1;
+    static constexpr size_t kFIELD_TYPE_BITS = sizeof(FieldType) * 8;
+    static constexpr FieldType kONE = 1;
 
     /** `refCounts` consists of four fields that are treated atomically:
 
@@ -137,21 +137,21 @@ private:
 
          */
 
-    mutable std::atomic<FieldType> refCounts_{kStrongDelta};
+    mutable std::atomic<FieldType> refCounts_{kSTRONG_DELTA};
 
     /**  Amount to change the strong count when adding or releasing a reference
 
          Note: The strong count is stored in the low `StrongCountNumBits` bits
        of refCounts
       */
-    static constexpr FieldType kStrongDelta = 1;
+    static constexpr FieldType kSTRONG_DELTA = 1;
 
     /**  Amount to change the weak count when adding or releasing a reference
 
          Note: The weak count is stored in the high `WeakCountNumBits` bits of
          refCounts
       */
-    static constexpr FieldType kWeakDelta = (kOne << kStrongCountNumBits);
+    static constexpr FieldType kWEAK_DELTA = (kONE << kSTRONG_COUNT_NUM_BITS);
 
     /**  Flag that is set when the partialDestroy function has started running
          (or is about to start running).
@@ -159,33 +159,34 @@ private:
          See description of the `refCounts` field for a fuller description of
          this field.
       */
-    static constexpr FieldType kPartialDestroyStartedMask = (kOne << (kFieldTypeBits - 1));
+    static constexpr FieldType kPARTIAL_DESTROY_STARTED_MASK = (kONE << (kFIELD_TYPE_BITS - 1));
 
     /**  Flag that is set when the partialDestroy function has finished running
 
          See description of the `refCounts` field for a fuller description of
          this field.
       */
-    static constexpr FieldType kPartialDestroyFinishedMask = (kOne << (kFieldTypeBits - 2));
+    static constexpr FieldType kPARTIAL_DESTROY_FINISHED_MASK = (kONE << (kFIELD_TYPE_BITS - 2));
 
     /** Mask that will zero out all the `count` bits and leave the tag bits
         unchanged.
       */
-    static constexpr FieldType kTagMask = kPartialDestroyStartedMask | kPartialDestroyFinishedMask;
+    static constexpr FieldType kTAG_MASK =
+        kPARTIAL_DESTROY_STARTED_MASK | kPARTIAL_DESTROY_FINISHED_MASK;
 
     /** Mask that will zero out the `tag` bits and leave the count bits
         unchanged.
       */
-    static constexpr FieldType kValueMask = ~kTagMask;
+    static constexpr FieldType kVALUE_MASK = ~kTAG_MASK;
 
     /** Mask that will zero out everything except the strong count.
      */
-    static constexpr FieldType kStrongMask = ((kOne << kStrongCountNumBits) - 1) & kValueMask;
+    static constexpr FieldType kSTRONG_MASK = ((kONE << kSTRONG_COUNT_NUM_BITS) - 1) & kVALUE_MASK;
 
     /** Mask that will zero out everything except the weak count.
      */
-    static constexpr FieldType kWeakMask =
-        (((kOne << kWeakCountNumBits) - 1) << kStrongCountNumBits) & kValueMask;
+    static constexpr FieldType kWEAK_MASK =
+        (((kONE << kWEAK_COUNT_NUM_BITS) - 1) << kSTRONG_COUNT_NUM_BITS) & kVALUE_MASK;
 
     /** Unpack the count and tag fields from the packed atomic integer form. */
     struct RefCountPair
@@ -210,29 +211,29 @@ private:
         [[nodiscard]] FieldType
         combinedValue() const noexcept;
 
-        static constexpr CountType kMaxStrongValue =
-            static_cast<CountType>((kOne << kStrongCountNumBits) - 1);
-        static constexpr CountType kMaxWeakValue =
-            static_cast<CountType>((kOne << kWeakCountNumBits) - 1);
+        static constexpr CountType kMAX_STRONG_VALUE =
+            static_cast<CountType>((kONE << kSTRONG_COUNT_NUM_BITS) - 1);
+        static constexpr CountType kMAX_WEAK_VALUE =
+            static_cast<CountType>((kONE << kWEAK_COUNT_NUM_BITS) - 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).
          */
-        static constexpr CountType kCheckStrongMaxValue = kMaxStrongValue - 32;
-        static constexpr CountType kCheckWeakMaxValue = kMaxWeakValue - 32;
+        static constexpr CountType kCHECK_STRONG_MAX_VALUE = kMAX_STRONG_VALUE - 32;
+        static constexpr CountType kCHECK_WEAK_MAX_VALUE = kMAX_WEAK_VALUE - 32;
     };
 };
 
 inline void
 IntrusiveRefCounts::addStrongRef() const noexcept
 {
-    refCounts_.fetch_add(kStrongDelta, std::memory_order_acq_rel);
+    refCounts_.fetch_add(kSTRONG_DELTA, std::memory_order_acq_rel);
 }
 
 inline void
 IntrusiveRefCounts::addWeakRef() const noexcept
 {
-    refCounts_.fetch_add(kWeakDelta, std::memory_order_acq_rel);
+    refCounts_.fetch_add(kWEAK_DELTA, std::memory_order_acq_rel);
 }
 
 inline ReleaseStrongRefAction
@@ -251,10 +252,10 @@ IntrusiveRefCounts::releaseStrongRef() const
     {
         RefCountPair const prevVal{prevIntVal};
         XRPL_ASSERT(
-            (prevVal.strong >= kStrongDelta),
+            (prevVal.strong >= kSTRONG_DELTA),
             "xrpl::IntrusiveRefCounts::releaseStrongRef : previous ref "
             "higher than new");
-        auto nextIntVal = prevIntVal - kStrongDelta;
+        auto nextIntVal = prevIntVal - kSTRONG_DELTA;
         ReleaseStrongRefAction action = NoOp;
         if (prevVal.strong == 1)
         {
@@ -264,7 +265,7 @@ IntrusiveRefCounts::releaseStrongRef() const
             }
             else
             {
-                nextIntVal |= kPartialDestroyStartedMask;
+                nextIntVal |= kPARTIAL_DESTROY_STARTED_MASK;
                 action = PartialDestroy;
             }
         }
@@ -275,7 +276,7 @@ IntrusiveRefCounts::releaseStrongRef() const
             // count to zero can start a partial destroy, and that can't happen
             // twice.
             XRPL_ASSERT(
-                (action == NoOp) || !(prevIntVal & kPartialDestroyStartedMask),
+                (action == NoOp) || !(prevIntVal & kPARTIAL_DESTROY_STARTED_MASK),
                 "xrpl::IntrusiveRefCounts::releaseStrongRef : not in partial "
                 "destroy");
             return action;
@@ -288,8 +289,8 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
 {
     using enum ReleaseStrongRefAction;
 
-    static_assert(kWeakDelta > kStrongDelta);
-    static constexpr auto kDelta = kWeakDelta - kStrongDelta;
+    static_assert(kWEAK_DELTA > kSTRONG_DELTA);
+    auto constexpr kDELTA = kWEAK_DELTA - kSTRONG_DELTA;
     auto prevIntVal = refCounts_.load(std::memory_order_acquire);
     // This loop will almost always run once. The loop is needed to atomically
     // change the counts and flags (the count could be atomically changed, but
@@ -311,7 +312,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
             "xrpl::IntrusiveRefCounts::addWeakReleaseStrongRef : not in "
             "partial destroy");
 
-        auto nextIntVal = prevIntVal + kDelta;
+        auto nextIntVal = prevIntVal + kDELTA;
         ReleaseStrongRefAction action = NoOp;
         if (prevVal.strong == 1)
         {
@@ -321,14 +322,14 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
             }
             else
             {
-                nextIntVal |= kPartialDestroyStartedMask;
+                nextIntVal |= kPARTIAL_DESTROY_STARTED_MASK;
                 action = PartialDestroy;
             }
         }
         if (refCounts_.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel))
         {
             XRPL_ASSERT(
-                (!(prevIntVal & kPartialDestroyStartedMask)),
+                (!(prevIntVal & kPARTIAL_DESTROY_STARTED_MASK)),
                 "xrpl::IntrusiveRefCounts::addWeakReleaseStrongRef : not "
                 "started partial destroy");
             return action;
@@ -339,7 +340,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
 inline ReleaseWeakRefAction
 IntrusiveRefCounts::releaseWeakRef() const
 {
-    auto prevIntVal = refCounts_.fetch_sub(kWeakDelta, std::memory_order_acq_rel);
+    auto prevIntVal = refCounts_.fetch_sub(kWEAK_DELTA, std::memory_order_acq_rel);
     RefCountPair prev = prevIntVal;
     if (prev.weak == 1 && prev.strong == 0)
     {
@@ -356,7 +357,7 @@ IntrusiveRefCounts::releaseWeakRef() const
         {
             // partial destroy MUST finish before running a full destroy (when
             // using weak pointers)
-            refCounts_.wait(prevIntVal - kWeakDelta, std::memory_order_acquire);
+            refCounts_.wait(prevIntVal - kWEAK_DELTA, std::memory_order_acquire);
         }
         return ReleaseWeakRefAction::Destroy;
     }
@@ -375,7 +376,7 @@ IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
         if (prev.strong == 0u)
             return false;
 
-        desiredValue = curValue + kStrongDelta;
+        desiredValue = curValue + kSTRONG_DELTA;
     }
     return true;
 }
@@ -399,22 +400,23 @@ inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept
 #ifndef NDEBUG
     auto v = refCounts_.load(std::memory_order_acquire);
     XRPL_ASSERT(
-        (!(v & kValueMask)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
-    auto t = v & kTagMask;
-    XRPL_ASSERT((!t || t == kTagMask), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
+        (!(v & kVALUE_MASK)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
+    auto t = v & kTAG_MASK;
+    XRPL_ASSERT(
+        (!t || t == kTAG_MASK), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
 #endif
 }
 
 //------------------------------------------------------------------------------
 
 inline IntrusiveRefCounts::RefCountPair::RefCountPair(IntrusiveRefCounts::FieldType v) noexcept
-    : strong{static_cast<CountType>(v & kStrongMask)}
-    , weak{static_cast<CountType>((v & kWeakMask) >> kStrongCountNumBits)}
-    , partialDestroyStartedBit{v & kPartialDestroyStartedMask}
-    , partialDestroyFinishedBit{v & kPartialDestroyFinishedMask}
+    : strong{static_cast<CountType>(v & kSTRONG_MASK)}
+    , weak{static_cast<CountType>((v & kWEAK_MASK) >> kSTRONG_COUNT_NUM_BITS)}
+    , partialDestroyStartedBit{v & kPARTIAL_DESTROY_STARTED_MASK}
+    , partialDestroyFinishedBit{v & kPARTIAL_DESTROY_FINISHED_MASK}
 {
     XRPL_ASSERT(
-        (strong < kCheckStrongMaxValue && weak < kCheckWeakMaxValue),
+        (strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE),
         "xrpl::IntrusiveRefCounts::RefCountPair(FieldType) : inputs inside "
         "range");
 }
@@ -425,7 +427,7 @@ inline IntrusiveRefCounts::RefCountPair::RefCountPair(
     : strong{s}, weak{w}
 {
     XRPL_ASSERT(
-        (strong < kCheckStrongMaxValue && weak < kCheckWeakMaxValue),
+        (strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE),
         "xrpl::IntrusiveRefCounts::RefCountPair(CountType, CountType) : "
         "inputs inside range");
 }
@@ -434,11 +436,11 @@ inline IntrusiveRefCounts::FieldType
 IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept
 {
     XRPL_ASSERT(
-        (strong < kCheckStrongMaxValue && weak < kCheckWeakMaxValue),
+        (strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE),
         "xrpl::IntrusiveRefCounts::RefCountPair::combinedValue : inputs "
         "inside range");
     return (static_cast<IntrusiveRefCounts::FieldType>(weak)
-            << IntrusiveRefCounts::kStrongCountNumBits) |
+            << IntrusiveRefCounts::kSTRONG_COUNT_NUM_BITS) |
         static_cast<IntrusiveRefCounts::FieldType>(strong) | partialDestroyStartedBit |
         partialDestroyFinishedBit;
 }
@@ -449,7 +451,7 @@ partialDestructorFinished(T** o)
 {
     T& self = **o;
     IntrusiveRefCounts::RefCountPair const p =
-        self.refCounts_.fetch_or(IntrusiveRefCounts::kPartialDestroyFinishedMask);
+        self.refCounts_.fetch_or(IntrusiveRefCounts::kPARTIAL_DESTROY_FINISHED_MASK);
     XRPL_ASSERT(
         (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong),
         "xrpl::partialDestructorFinished : not a weak ref");

include/xrpl/basics/LocalValue.h

@@ -55,8 +55,8 @@ template <class = void>
 boost::thread_specific_ptr<detail::LocalValues>&
 getLocalValues()
 {
-    static boost::thread_specific_ptr<detail::LocalValues> kTsp(&detail::LocalValues::cleanup);
-    return kTsp;
+    static boost::thread_specific_ptr<detail::LocalValues> kTSP(&detail::LocalValues::cleanup);
+    return kTSP;
 }
 
 }  // namespace detail

include/xrpl/basics/Log.h

@@ -10,11 +10,24 @@
 #include <map>
 #include <memory>
 #include <mutex>
-#include <optional>
 #include <utility>
 
 namespace xrpl {
 
+// DEPRECATED use beast::severities::Severity instead
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
+enum LogSeverity {
+    LSInvalid = -1,  // used to indicate an invalid severity
+    LSTrace = 0,     // Very low-level progress information, details inside
+                     // an operation
+    LSDebug = 1,     // Function-level progress information, operations
+    LSInfo = 2,      // Server-level progress information, major operations
+    LSWarning = 3,   // Conditions that warrant human attention, may indicate
+                     // a problem
+    LSError = 4,     // A condition that indicates a problem
+    LSFatal = 5      // A severe condition that indicates a server problem
+};
+
 /** Manages partitions for logging. */
 class Logs
 {
@@ -26,17 +39,17 @@ private:
         std::string partition_;
 
     public:
-        Sink(std::string partition, beast::Severity thresh, Logs& logs);
+        Sink(std::string partition, beast::severities::Severity thresh, Logs& logs);
 
         Sink(Sink const&) = delete;
         Sink&
         operator=(Sink const&) = delete;
 
         void
-        write(beast::Severity level, std::string const& text) override;
+        write(beast::severities::Severity level, std::string const& text) override;
 
         void
-        writeAlways(beast::Severity level, std::string const& text) override;
+        writeAlways(beast::severities::Severity level, std::string const& text) override;
     };
 
     /** Manages a system file containing logged output.
@@ -123,12 +136,12 @@ private:
 
     std::mutex mutable mutex_;
     std::map<std::string, std::unique_ptr<beast::Journal::Sink>, boost::beast::iless> sinks_;
-    beast::Severity thresh_;
+    beast::severities::Severity thresh_;
     File file_;
     bool silent_ = false;
 
 public:
-    Logs(beast::Severity level);
+    Logs(beast::severities::Severity level);
 
     Logs(Logs const&) = delete;
     Logs&
@@ -148,18 +161,18 @@ public:
     beast::Journal
     journal(std::string const& name);
 
-    beast::Severity
+    beast::severities::Severity
     threshold() const;
 
     void
-    threshold(beast::Severity thresh);
+    threshold(beast::severities::Severity thresh);
 
     std::vector<std::pair<std::string, std::string>>
     partitionSeverities() const;
 
     void
     write(
-        beast::Severity level,
+        beast::severities::Severity level,
         std::string const& partition,
         std::string const& text,
         bool console);
@@ -179,25 +192,36 @@ public:
     }
 
     virtual std::unique_ptr<beast::Journal::Sink>
-    makeSink(std::string const& partition, beast::Severity startingLevel);
+    makeSink(std::string const& partition, beast::severities::Severity startingLevel);
 
 public:
-    static std::string
-    toString(beast::Severity s);
+    static LogSeverity
+    fromSeverity(beast::severities::Severity level);
 
-    static std::optional<beast::Severity>
+    static beast::severities::Severity
+    toSeverity(LogSeverity level);
+
+    static std::string
+    toString(LogSeverity s);
+
+    static LogSeverity
     fromString(std::string const& s);
 
 private:
-    // Maximum line length for log messages.
-    // If the message exceeds this length it will be truncated with ellipses.
-    static constexpr auto kMaximumMessageCharacters = 12 * 1024;
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
+    enum {
+        // Maximum line length for log messages.
+        // If the message exceeds this length it will be truncated with
+        // ellipses.
+        MaximumMessageCharacters = 12 * 1024
+    };
 
     static void
     format(
         std::string& output,
         std::string const& message,
-        beast::Severity severity,
+        beast::severities::Severity severity,
         std::string const& partition);
 };
 

include/xrpl/basics/Logger.h

@@ -0,0 +1,587 @@
+#pragma once
+
+#include <xrpl/basics/Expected.h>
+#include <xrpl/basics/StructuredLogging.h>
+
+#include <fmt/format.h>
+
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <source_location>
+#include <string>
+#include <string_view>
+#include <vector>
+
+// We forward declare spdlog types to avoid including the spdlog headers in this header file.
+namespace spdlog {
+
+class logger;     // NOLINT(readability-identifier-naming)
+class formatter;  // NOLINT(readability-identifier-naming)
+
+namespace sinks {
+class sink;  // NOLINT(readability-identifier-naming)
+}  // namespace sinks
+
+}  // namespace spdlog
+
+class LoggerFixture;
+
+namespace xrpl {
+
+/**
+ * @brief Skips evaluation of expensive argument lists if the given logger is disabled for the
+ * required severity level.
+ *
+ * Note: Currently this introduces potential shadowing (unlikely).
+ */
+#ifndef COVERAGE_ENABLED
+#define LOG(x)                              \
+    if (auto xrpl_pump__ = x; !xrpl_pump__) \
+    {                                       \
+    }                                       \
+    else                                    \
+        xrpl_pump__
+#else
+#define LOG(x) x
+#endif
+
+/**
+ * @brief Custom severity levels for @ref util::Logger.
+ */
+enum class Severity {
+    TRC,
+    DBG,
+    NFO,
+    WRN,
+    ERR,
+    FTL,
+};
+
+/**
+ * @brief The default log format pattern for non-JSON mode.
+ *
+ * Matches the legacy Logs::format output:
+ *   2024-Jan-15 12:34:56.789123 UTC General:NFO hello world
+ *
+ * '%K' is a custom flag that outputs the three-letter severity code
+ * (TRC, DBG, NFO, WRN, ERR, FTL).
+ */
+inline constexpr char const* kDEFAULT_LOG_FORMAT = "%Y-%b-%d %H:%M:%S.%f UTC %n:%K %v";
+
+/**
+ * @brief Build the default JSON log format pattern.
+ *
+ * Contains the same fields as @ref kDEFAULT_LOG_FORMAT (timestamp, channel,
+ * severity) plus the trailing message placeholder:
+ * @code
+ *   {"timestamp":"2024-Jan-15 12:34:56.789123 UTC","channel":"General","severity":"NFO",
+ *    "message": "hello world" }
+ * @endcode
+ */
+inline std::string
+defaultJsonLogFormat()
+{
+    using sv = std::string_view;
+    return buildJsonPattern(
+        "",
+        log::param("timestamp", sv("%Y-%b-%d %H:%M:%S.%f UTC")),
+        log::param("channel", sv("%n")),
+        log::param("severity", sv("%K")));
+}
+
+struct LoggingConfiguration
+{
+    bool enableConsole{};
+    std::optional<std::string> directory{std::nullopt};
+    bool isAsync{};
+    Severity defaultSeverity{Severity::DBG};
+    bool jsonMode{false};
+};
+
+/**
+ * @brief A simple thread-safe logger for the channel specified
+ * in the constructor.
+ *
+ * This is cheap to copy and move. Designed to be used as a member variable or
+ * otherwise. See @ref LogService::init() for setup of the logging core and
+ * severity levels for each channel.
+ */
+class Logger
+{
+    std::shared_ptr<spdlog::logger> logger_;
+    std::string contextParams_;  // inherited parameter fragments (JSON or text)
+    bool jsonMode_ = false;      // captured at construction from LogServiceState
+
+    friend class LogService;  // to expose the Pump interface
+
+    /**
+     * @brief Helper that pumps data into a log record via `operator<<`.
+     */
+    class Pump final
+    {
+        spdlog::logger* logger_;
+        Severity const severity_;
+        std::source_location const sourceLocation_;
+        fmt::memory_buffer stream_;
+        bool const enabled_;
+        bool const jsonMode_;
+        std::string_view contextParams_;  // points into Logger's string (no copy)
+        std::string messageParams_;       // per-message params (JSON mode only)
+
+    public:
+        ~Pump();
+
+        Pump(
+            spdlog::logger* logger,
+            Severity sev,
+            std::source_location const& loc,
+            bool jsonMode,
+            std::string_view contextParams = {});
+
+        Pump(Pump&&) = delete;
+        Pump(Pump const&) = delete;
+        Pump&
+        operator=(Pump const&) = delete;
+        Pump&
+        operator=(Pump&&) = delete;
+
+        /**
+         * @brief Appends data that has an @c xrpl::to_string overload.
+         *
+         * This covers all XRP Ledger domain types such as @c Number,
+         * @c Currency, @c AccountID, @c XRPAmount, @c IOUAmount, @c Asset, etc.
+         *
+         * @tparam T Type of data to pump (must satisfy detail::HasToString)
+         * @param data The data to pump
+         * @return Reference to itself for chaining
+         */
+        template <typename T>
+            requires(detail::HasToString<T>)
+        [[maybe_unused]] Pump&
+        operator<<(T&& data)
+        {
+            if (enabled_)
+            {
+                auto const s = to_string(data);
+                stream_.append(s.data(), s.data() + s.size());
+            }
+            return *this;
+        }
+
+        /**
+         * @brief Appends any fmt-formattable data into the output buffer.
+         *
+         * Fallback for types that do not have an @c xrpl::to_string overload
+         * but can be formatted by @c fmt::format (e.g. arithmetic types,
+         * @c std::string, @c std::string_view).
+         *
+         * @tparam T Type of data to pump
+         * @param data The data to pump
+         * @return Reference to itself for chaining
+         */
+        template <typename T>
+            requires(!detail::HasToString<T>)
+        [[maybe_unused]] Pump&
+        operator<<(T&& data)
+        {
+            if (enabled_)
+                fmt::format_to(fmt::appender(stream_), "{}", std::forward<T>(data));
+            return *this;
+        }
+
+        /**
+         * @brief Captures a structured log parameter.
+         *
+         * The parameter value is always appended to the output buffer.
+         * In JSON mode, the parameter is also accumulated into the
+         * parameters string for the "values" object emitted in the
+         * destructor.
+         *
+         * @tparam T Type of the parameter value
+         * @param p The parameter to capture
+         * @return Reference to itself for chaining
+         */
+        template <typename T>
+        [[maybe_unused]] Pump&
+        operator<<(xrpl::log::Parameter<T> p)
+        {
+            if (enabled_)
+            {
+                // Append the raw string representation to the output buffer
+                if constexpr (detail::HasToString<T>)
+                {
+                    auto const s = to_string(p.value());
+                    stream_.append(s.data(), s.data() + s.size());
+                }
+                else
+                {
+                    fmt::format_to(fmt::appender(stream_), "{}", std::move(p.value()));
+                }
+
+                if (jsonMode_)
+                {
+                    detail::appendJsonField(messageParams_, p.name(), p.value());
+                }
+            }
+
+            return *this;
+        }
+
+        /**
+         * @return true if logger is enabled; false otherwise
+         */
+        operator bool() const
+        {
+            return enabled_;
+        }
+    };
+
+public:
+    /**
+     * @brief Construct a new Logger object that produces loglines for the
+     * specified channel.
+     *
+     * See @ref LogService::init() for general setup and configuration of
+     * severity levels per channel.
+     *
+     * @param channel The channel this logger will report into.
+     */
+    Logger(std::string_view const channel);
+
+    /**
+     * @brief Construct a child Logger that inherits context from a parent.
+     *
+     * The child uses a new channel and carries all of the parent's context
+     * parameters plus any additional parameters supplied here.  Every log
+     * line produced by the child will automatically include these
+     * parameters in the JSON @c values object.
+     *
+     * @tparam Ts Value types of the extra parameters.
+     * @param parent The parent Logger whose context is inherited.
+     * @param channel The channel name for this child logger.
+     * @param params Extra context parameters to attach.
+     */
+    template <typename... Ts>
+    Logger(Logger const& parent, std::string_view channel, log::Parameter<Ts> const&... params)
+        : Logger(channel)
+    {
+        contextParams_ = parent.contextParams_;
+        (appendContextParam(params), ...);
+    }
+
+    Logger(Logger const&) = default;
+    ~Logger();
+
+    Logger(Logger&&) = default;
+    Logger&
+    operator=(Logger const&) = default;
+
+    Logger&
+    operator=(Logger&&) = default;
+
+    /**
+     * @brief Interface for logging at Severity::TRC severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] Pump
+    trace(std::source_location const& loc = std::source_location::current()) const;
+
+    /**
+     * @brief Interface for logging at Severity::DBG severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] Pump
+    debug(std::source_location const& loc = std::source_location::current()) const;
+
+    /**
+     * @brief Interface for logging at Severity::NFO severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] Pump
+    info(std::source_location const& loc = std::source_location::current()) const;
+
+    /**
+     * @brief Interface for logging at Severity::WRN severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] Pump
+    warn(std::source_location const& loc = std::source_location::current()) const;
+
+    /**
+     * @brief Interface for logging at Severity::ERR severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] Pump
+    error(std::source_location const& loc = std::source_location::current()) const;
+
+    /**
+     * @brief Interface for logging at Severity::FTL severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] Pump
+    fatal(std::source_location const& loc = std::source_location::current()) const;
+
+private:
+    Logger(std::shared_ptr<spdlog::logger> logger);
+
+    /** @brief Serialise a single parameter into contextParams_. */
+    template <typename T>
+    void
+    appendContextParam(log::Parameter<T> const& p)
+    {
+        if (jsonMode_)
+        {
+            detail::appendJsonField(contextParams_, p.name(), p.value());
+        }
+        else
+        {
+            detail::appendTextField(contextParams_, p.name(), p.value());
+        }
+    }
+};
+
+/**
+ * @brief Base state management class for the logging service.
+ *
+ * This class manages the global state and core functionality for the logging system,
+ * including initialization, sink management, and logger registration.
+ */
+class LogServiceState
+{
+protected:
+    friend class ::LoggerFixture;
+    friend class Logger;
+
+    /**
+     * @brief Initialize the logging core with specified parameters.
+     *
+     * @param isAsync Whether logging should be asynchronous
+     * @param defaultSeverity The default severity level for new loggers
+     * @param sinks Vector of spdlog sinks to use for output
+     */
+    static void
+    init(
+        bool isAsync,
+        Severity defaultSeverity,
+        std::vector<std::shared_ptr<spdlog::sinks::sink>> const& sinks,
+        bool jsonMode = false);
+
+    /**
+     * @brief Whether the LogService is initialized or not
+     *
+     * @return true if the LogService is initialized
+     */
+    [[nodiscard]] static bool
+    initialized();
+
+    /**
+     * @brief Whether the LogService has any sink. If there is no sink, logger will not log messages
+     * anywhere.
+     *
+     * @return true if the LogService has at least one sink
+     */
+    [[nodiscard]] static bool
+    hasSinks();
+
+    /**
+     * @brief Reset the logging service to uninitialized state.
+     */
+    static void
+    reset();
+
+    /**
+     * @brief Register a new logger for the specified channel.
+     *
+     * Creates and registers a new spdlog logger instance for the given channel
+     * with the specified or default severity level.
+     *
+     * @param channel The name of the logging channel
+     * @param severity Optional severity level override; uses default if not specified
+     * @return Shared pointer to the registered spdlog logger
+     */
+    static std::shared_ptr<spdlog::logger>
+    registerLogger(std::string_view channel, std::optional<Severity> severity = std::nullopt);
+
+    /**
+     * @brief Replace the current sinks with a new set of sinks.
+     *
+     * @param sinks Vector of new spdlog sinks to replace the current ones
+     */
+    static void
+    replaceSinks(std::vector<std::shared_ptr<spdlog::sinks::sink>> const& sinks);
+
+    /**
+     * @brief Creates a pattern formatter with custom flags (e.g. '%K' for
+     * severity) and UTC timestamps.
+     *
+     * @param pattern The spdlog pattern string
+     * @return A unique_ptr to the configured pattern_formatter
+     */
+    static std::unique_ptr<spdlog::formatter>
+    makeFormatter(std::string const& pattern);
+
+    /**
+     * @brief Creates a formatter that suppresses critical-level messages.
+     *
+     * Wraps the given formatter so that only messages below critical severity
+     * are formatted.  Critical messages produce no output through this
+     * formatter (they are routed to a separate stderr sink instead).
+     *
+     * @param wrappedFormatter The underlying formatter to delegate to
+     * @return A unique_ptr to the NonCriticalFormatter
+     */
+    static std::unique_ptr<spdlog::formatter>
+    makeNonCriticalFormatter(std::unique_ptr<spdlog::formatter> wrappedFormatter);
+
+    /**
+     * @brief Returns the active log format pattern.
+     *
+     * Automatically determined by the logging mode:
+     * text mode uses @ref kDEFAULT_LOG_FORMAT, JSON mode uses
+     * @ref defaultJsonLogFormat().
+     */
+    static std::string const&
+    format()
+    {
+        return format_;
+    }
+
+protected:
+    static bool isAsync_;              // NOLINT(readability-identifier-naming)
+    static Severity defaultSeverity_;  // NOLINT(readability-identifier-naming)
+    static std::vector<std::shared_ptr<spdlog::sinks::sink>>
+        sinks_;                                 // NOLINT(readability-identifier-naming)
+    static bool initialized_;                   // NOLINT(readability-identifier-naming)
+    static bool jsonMode_;                      // NOLINT(readability-identifier-naming)
+    static std::optional<std::string> logDir_;  // NOLINT(readability-identifier-naming)
+    static std::string format_;                 // NOLINT(readability-identifier-naming)
+};
+
+/**
+ * @brief A global logging service.
+ *
+ * Used to initialize and setup the logging core as well as a globally available
+ * entrypoint for logging into the `General` channel as well as raising alerts.
+ */
+class LogService : public LogServiceState
+{
+public:
+    LogService() = delete;
+
+    /**
+     * @brief Global log core initialization from a @ref LoggingConfiguration
+     *
+     * @param config The configuration to use
+     * @return Void on success, error message on failure
+     */
+    [[nodiscard]] static Expected<void, std::string>
+    init(LoggingConfiguration const& config);
+
+    /**
+     * @brief Shutdown spdlog to guarantee output is not lost
+     */
+    static void
+    shutdown();
+
+    /**
+     * @brief Close and reopen the log file.
+     *
+     * This assists in interoperating with external log management tools
+     * such as logrotate(8). If no file logging is configured, this is a no-op.
+     *
+     * @return A human-readable status message
+     */
+    [[nodiscard]] static std::string
+    rotate();
+
+    /**
+     * @brief Globally accessible General logger at Severity::TRC severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] static Logger::Pump
+    trace(std::source_location const& loc = std::source_location::current());
+
+    /**
+     * @brief Globally accessible General logger at Severity::DBG severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] static Logger::Pump
+    debug(std::source_location const& loc = std::source_location::current());
+
+    /**
+     * @brief Globally accessible General logger at Severity::NFO severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] static Logger::Pump
+    info(std::source_location const& loc = std::source_location::current());
+
+    /**
+     * @brief Globally accessible General logger at Severity::WRN severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] static Logger::Pump
+    warn(std::source_location const& loc = std::source_location::current());
+
+    /**
+     * @brief Globally accessible General logger at Severity::ERR severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] static Logger::Pump
+    error(std::source_location const& loc = std::source_location::current());
+
+    /**
+     * @brief Globally accessible General logger at Severity::FTL severity
+     *
+     * @param loc The source location of the log message
+     * @return The pump to use for logging
+     */
+    [[nodiscard]] static Logger::Pump
+    fatal(std::source_location const& loc = std::source_location::current());
+
+private:
+    /**
+     * @brief Parses the sinks from a @ref LoggingConfiguration
+     *
+     * @param config The configuration to parse sinks from
+     * @return A vector of sinks on success, error message on failure
+     */
+    [[nodiscard]] static Expected<std::vector<std::shared_ptr<spdlog::sinks::sink>>, std::string>
+    getSinks(LoggingConfiguration const& config, std::string const& format);
+
+    struct FileLoggingParams
+    {
+        std::string logDir;
+    };
+
+    friend class ::LoggerFixture;
+
+    [[nodiscard]]
+    static std::shared_ptr<spdlog::sinks::sink>
+    createFileSink(FileLoggingParams const& params, std::string const& format);
+};
+
+};  // namespace xrpl

include/xrpl/basics/Number.h

@@ -2,16 +2,12 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <array>
 #include <cstdint>
 #include <functional>
 #include <limits>
 #include <optional>
 #include <ostream>
-#include <set>
-#include <stdexcept>
 #include <string>
-#include <unordered_map>
 
 namespace xrpl {
 
@@ -42,58 +38,17 @@ isPowerOfTen(T value)
     return logTen(value).has_value();
 }
 
-namespace detail {
-
-/** Builds a table of the powers of 10
- *
- * This function is marked consteval, so it can only be run in
- * a constexpr context. This assures that it is and can only be run at
- * compile time. Doing it at runtime would be pretty wasteful and
- * inefficient.
- */
-constexpr std::size_t kInt64Digits = 20;
-consteval std::array<std::uint64_t, kInt64Digits>
-buildPowersOfTen()
-{
-    std::array<std::uint64_t, kInt64Digits> result{};
-
-    std::uint64_t power = 1;
-    std::size_t exponent = 0;
-    // end the loop early so it doesn't overflow;
-    for (; exponent < result.size() - 1; ++exponent, power *= 10)
-    {
-        result[exponent] = power;
-        if (power > std::numeric_limits<std::uint64_t>::max() / 10)
-            throw std::logic_error("Power of 10 table is too big");
-    }
-    result[exponent] = power;
-    if (power < std::numeric_limits<std::uint64_t>::max() / 10)
-        throw std::logic_error("Power of 10 table is not big enough for the uint64_t type");
-
-    return result;
-}
-
-}  // namespace detail
-
-constexpr std::array<std::uint64_t, detail::kInt64Digits> kPowerOfTen = detail::buildPowersOfTen();
-
-static_assert(kPowerOfTen[0] == 1);
-static_assert(kPowerOfTen[1] == 10);
-static_assert(kPowerOfTen[10] == 10'000'000'000);
-static_assert(
-    isPowerOfTen(kPowerOfTen.back()) && *logTen(kPowerOfTen.back()) == detail::kInt64Digits - 1);
-
 /** MantissaRange defines a range for the mantissa of a normalized Number.
  *
  * The mantissa is in the range [min, max], where
  * * min is a power of 10, and
  * * max = min * 10 - 1.
  *
- * The MantissaScale enum indicates properties of the range: size, and some behavioral
- * options. This intentionally restricts the number of unique MantissaRanges that can
- * be instantiated: one for each scale.
+ * The mantissa_scale enum indicates whether the range is "small" or "large".
+ * This intentionally restricts the number of MantissaRanges that can be
+ * instantiated to two: one for each scale.
  *
- * The "Small" scale is based on the behavior of STAmount for IOUs. It has a min
+ * The "small" scale is based on the behavior of STAmount for IOUs. It has a min
  * value of 10^15, and a max value of 10^16-1. This was sufficient for
  * uses before Lending Protocol was implemented, mostly related to AMM.
  *
@@ -104,100 +59,46 @@ static_assert(
  * STNumber field type, and for internal calculations. That necessitated the
  * "large" scale.
  *
- * The "Large" scales are intended to represent all values that can be represented
+ * The "large" scale is intended to represent all values that can be represented
  * by an STAmount - IOUs, XRP, and MPTs. It has a min value of 10^18, and a max
- * value of 10^19-1. "LargeLegacy" is like "Large", but preserves
- * a rounding error when a computation results in a mantissa of
- * Number::kMaxRep that needs to be rounded up, but rounds down
- * instead. It will maintain consistent behavior until the fixCleanup3_2_0
- * amendment is enabled.
+ * value of 10^19-1.
  *
  * Note that if the mentioned amendments are eventually retired, this class
- * should be left in place, but the "Small" scale option should be removed. This
+ * should be left in place, but the "small" scale option should be removed. This
  * will allow for future expansion beyond 64-bits if it is ever needed.
  */
-struct MantissaRange final
+struct MantissaRange
 {
     using rep = std::uint64_t;
+    enum class MantissaScale { Small, Large };
 
-    enum class MantissaScale {
-        Small,
-        // LargeLegacy can be removed when fixCleanup3_2_0 is retired
-        LargeLegacy,
-        Large,
-    };
-
-    // This entire enum can be removed when fixCleanup3_2_0 is retired
-    enum class CuspRoundingFix : bool {
-        Disabled = false,
-        Enabled = true,
-    };
-
-    explicit constexpr MantissaRange(MantissaScale sc) : scale(sc)
+    explicit constexpr MantissaRange(MantissaScale scale)
+        : min(getMin(scale)), log(logTen(min).value_or(-1)), scale(scale)
     {
     }
 
-    MantissaScale const scale;
-    int const log{getExponent(scale)};
-    rep const min{getMin(scale, log)};
-    rep const max{(min * 10) - 1};
-    CuspRoundingFix const cuspRoundingFixEnabled{isCuspFixEnabled(scale)};
-
-    static MantissaRange const&
-    getMantissaRange(MantissaScale scale);
-
-    static std::set<MantissaScale> const&
-    getAllScales();
+    rep min;
+    rep max{(min * 10) - 1};
+    int log;
+    MantissaScale scale;
 
 private:
-    static constexpr int
-    getExponent(MantissaScale scale)
+    static constexpr rep
+    getMin(MantissaScale scale)
     {
         switch (scale)
         {
             case MantissaScale::Small:
-                return 15;
-            case MantissaScale::LargeLegacy:
+                return 1'000'000'000'000'000ULL;
             case MantissaScale::Large:
-                return 18;
-            // LCOV_EXCL_START
+                return 1'000'000'000'000'000'000ULL;
             default:
-                // If called in a constexpr context, this throw assures that the build fails if an
+                // Since this can never be called outside a non-constexpr
+                // context, this throw assures that the build fails if an
                 // invalid scale is used.
                 throw std::runtime_error("Unknown mantissa scale");
-                // LCOV_EXCL_STOP
         }
     }
-
-    // Keep this function for future use with different ways to compute
-    // the ranges.
-    static constexpr rep
-    getMin(MantissaScale scale, int exponent)
-    {
-        if (exponent < 0 || exponent >= kPowerOfTen.size())
-            throw std::runtime_error("Invalid exponent");  // LCOV_EXCL_LINE
-        return kPowerOfTen[exponent];
-    }
-
-    static constexpr CuspRoundingFix
-    isCuspFixEnabled(MantissaScale scale)
-    {
-        switch (scale)
-        {
-            case MantissaScale::Small:
-            case MantissaScale::LargeLegacy:
-                return CuspRoundingFix::Disabled;
-            case MantissaScale::Large:
-                return CuspRoundingFix::Enabled;
-            default:
-                // If called in a constexpr context, this throw assures that the build fails if an
-                // invalid scale is used.
-                throw std::runtime_error("Unknown mantissa scale");  // LCOV_EXCL_LINE
-        }
-    }
-
-    static std::unordered_map<MantissaScale, MantissaRange> const&
-    getRanges();
 };
 
 // Like std::integral, but only 64-bit integral types.
@@ -302,7 +203,7 @@ concept Integral64 = std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::u
  * amendments are enabled to determine which result to expect.
  *
  */
-class Number final
+class Number
 {
     using rep = std::int64_t;
     using internalrep = MantissaRange::rep;
@@ -313,12 +214,12 @@ class Number final
 
 public:
     // The range for the exponent when normalized
-    static constexpr int kMinExponent = -32768;
-    static constexpr int kMaxExponent = 32768;
+    constexpr static int kMIN_EXPONENT = -32768;
+    constexpr static int kMAX_EXPONENT = 32768;
 
-    static constexpr internalrep kMaxRep = std::numeric_limits<rep>::max();
-    static_assert(kMaxRep == 9'223'372'036'854'775'807);
-    static_assert(-kMaxRep == std::numeric_limits<rep>::min() + 1);
+    constexpr static internalrep kMAX_REP = std::numeric_limits<rep>::max();
+    static_assert(kMAX_REP == 9'223'372'036'854'775'807);
+    static_assert(-kMAX_REP == std::numeric_limits<rep>::min() + 1);
 
     // May need to make unchecked private
     struct Unchecked
@@ -508,48 +409,69 @@ public:
     static internalrep
     minMantissa()
     {
-        return kRange.get().min;
+        return kRANGE.get().min;
     }
 
     static internalrep
     maxMantissa()
     {
-        return kRange.get().max;
+        return kRANGE.get().max;
     }
 
     static int
     mantissaLog()
     {
-        return kRange.get().log;
+        return kRANGE.get().log;
     }
 
+    /// oneSmall is needed because the ranges are private
+    constexpr static Number
+    oneSmall();
+    /// oneLarge is needed because the ranges are private
+    constexpr static Number
+    oneLarge();
+
+    // And one is needed because it needs to choose between oneSmall and
+    // oneLarge based on the current range
     static Number
     one();
 
-    template <
-        auto MinMantissa,
-        auto MaxMantissa,
-        Integral64 T = std::decay_t<decltype(MinMantissa)>>
+    template <Integral64 T>
     [[nodiscard]]
     std::pair<T, int>
-    normalizeToRange() const;
+    normalizeToRange(T minMantissa, T maxMantissa) const;
 
 private:
     static thread_local RoundingMode mode;
     // The available ranges for mantissa
 
+    constexpr static MantissaRange kSMALL_RANGE{MantissaRange::MantissaScale::Small};
+    static_assert(isPowerOfTen(kSMALL_RANGE.min));
+    static_assert(kSMALL_RANGE.min == 1'000'000'000'000'000LL);
+    static_assert(kSMALL_RANGE.max == 9'999'999'999'999'999LL);
+    static_assert(kSMALL_RANGE.log == 15);
+    static_assert(kSMALL_RANGE.min < kMAX_REP);
+    static_assert(kSMALL_RANGE.max < kMAX_REP);
+    constexpr static MantissaRange kLARGE_RANGE{MantissaRange::MantissaScale::Large};
+    static_assert(isPowerOfTen(kLARGE_RANGE.min));
+    static_assert(kLARGE_RANGE.min == 1'000'000'000'000'000'000ULL);
+    static_assert(kLARGE_RANGE.max == internalrep(9'999'999'999'999'999'999ULL));
+    static_assert(kLARGE_RANGE.log == 18);
+    static_assert(kLARGE_RANGE.min < kMAX_REP);
+    static_assert(kLARGE_RANGE.max > kMAX_REP);
+
     // The range for the mantissa when normalized.
     // Use reference_wrapper to avoid making copies, and prevent accidentally
     // changing the values inside the range.
-    static thread_local std::reference_wrapper<MantissaRange const> kRange;
+    static thread_local std::reference_wrapper<MantissaRange const> kRANGE;
 
     void
-    normalize(MantissaRange const& range);
+    normalize();
 
     /** Normalize Number components to an arbitrary range.
      *
      * min/maxMantissa are parameters because this function is used by both
-     * normalize(), which reads from kRange, and by normalizeToRange,
+     * normalize(), which reads from kRANGE, and by normalizeToRange,
      * which is public and can accept an arbitrary range from the caller.
      */
     template <class T>
@@ -559,8 +481,7 @@ private:
         T& mantissa,
         int& exponent,
         internalrep const& minMantissa,
-        internalrep const& maxMantissa,
-        MantissaRange::CuspRoundingFix cuspRoundingFixEnabled);
+        internalrep const& maxMantissa);
 
     template <class T>
     friend void
@@ -569,9 +490,7 @@ private:
         T& mantissa,
         int& exponent,
         MantissaRange::rep const& minMantissa,
-        MantissaRange::rep const& maxMantissa,
-        MantissaRange::CuspRoundingFix cuspRoundingFixEnabled,
-        bool dropped);
+        MantissaRange::rep const& maxMantissa);
 
     [[nodiscard]] bool
     isnormal() const noexcept;
@@ -602,12 +521,12 @@ constexpr Number::Number(internalrep mantissa, int exponent, Unchecked) noexcept
 {
 }
 
-static constexpr Number kNumZero{};
+constexpr static Number kNUM_ZERO{};
 
 inline Number::Number(bool negative, internalrep mantissa, int exponent, Normalized)
     : Number(negative, mantissa, exponent, Unchecked{})
 {
-    normalize(kRange);
+    normalize();
 }
 
 inline Number::Number(internalrep mantissa, int exponent, Normalized)
@@ -633,10 +552,10 @@ constexpr Number::rep
 Number::mantissa() const noexcept
 {
     auto m = mantissa_;
-    if (m > kMaxRep)
+    if (m > kMAX_REP)
     {
         XRPL_ASSERT_PARTS(
-            !isnormal() || (m % 10 == 0 && m / 10 <= kMaxRep),
+            !isnormal() || (m % 10 == 0 && m / 10 <= kMAX_REP),
             "xrpl::Number::mantissa",
             "large normalized mantissa has no remainder");
         m /= 10;
@@ -654,10 +573,10 @@ constexpr int
 Number::exponent() const noexcept
 {
     auto e = exponent_;
-    if (mantissa_ > kMaxRep)
+    if (mantissa_ > kMAX_REP)
     {
         XRPL_ASSERT_PARTS(
-            !isnormal() || (mantissa_ % 10 == 0 && mantissa_ / 10 <= kMaxRep),
+            !isnormal() || (mantissa_ % 10 == 0 && mantissa_ / 10 <= kMAX_REP),
             "xrpl::Number::exponent",
             "large normalized mantissa has no remainder");
         ++e;
@@ -752,46 +671,35 @@ operator/(Number const& x, Number const& y)
 inline Number
 Number::min() noexcept
 {
-    return Number{false, kRange.get().min, kMinExponent, Unchecked{}};
+    return Number{false, kRANGE.get().min, kMIN_EXPONENT, Unchecked{}};
 }
 
 inline Number
 Number::max() noexcept
 {
-    return Number{false, std::min(kRange.get().max, kMaxRep), kMaxExponent, Unchecked{}};
+    return Number{false, std::min(kRANGE.get().max, kMAX_REP), kMAX_EXPONENT, Unchecked{}};
 }
 
 inline Number
 Number::lowest() noexcept
 {
-    return Number{true, std::min(kRange.get().max, kMaxRep), kMaxExponent, Unchecked{}};
+    return Number{true, std::min(kRANGE.get().max, kMAX_REP), kMAX_EXPONENT, Unchecked{}};
 }
 
 inline bool
 Number::isnormal() const noexcept
 {
-    MantissaRange const& range = kRange;
+    MantissaRange const& range = kRANGE;
     auto const absM = mantissa_;
     return *this == Number{} ||
-        (range.min <= absM && absM <= range.max && (absM <= kMaxRep || absM % 10 == 0) &&
-         kMinExponent <= exponent_ && exponent_ <= kMaxExponent);
+        (range.min <= absM && absM <= range.max && (absM <= kMAX_REP || absM % 10 == 0) &&
+         kMIN_EXPONENT <= exponent_ && exponent_ <= kMAX_EXPONENT);
 }
 
-template <auto MinMantissa, auto MaxMantissa, Integral64 T>
+template <Integral64 T>
 std::pair<T, int>
-Number::normalizeToRange() const
+Number::normalizeToRange(T minMantissa, T maxMantissa) const
 {
-    static_assert(std::is_same_v<T, std::uint64_t> || std::is_same_v<T, std::int64_t>);
-    static_assert(std::is_same_v<T, std::decay_t<decltype(MinMantissa)>>);
-    static_assert(std::is_same_v<T, std::decay_t<decltype(MaxMantissa)>>);
-    auto constexpr kMIN = static_cast<T>(MinMantissa);
-    auto constexpr kMAX = static_cast<T>(MaxMantissa);
-    static_assert(kMIN > 0);
-    static_assert(kMIN % 10 == 0);
-    static_assert(isPowerOfTen(kMIN));
-    static_assert(kMAX % 10 == 9);
-    static_assert((kMAX + 1) / 10 == kMIN);
-
     bool negative = negative_;
     internalrep mantissa = mantissa_;
     int exponent = exponent_;
@@ -803,10 +711,7 @@ Number::normalizeToRange() const
             "xrpl::Number::normalizeToRange",
             "Number is non-negative for unsigned range.");
     }
-    // Don't need to worry about the cuspRounding fix because rounding up will never take the
-    // mantissa over maxMantissa with a ones digit value other than 0. 0 can safely be truncated.
-    Number::normalize(
-        negative, mantissa, exponent, kMIN, kMAX, MantissaRange::CuspRoundingFix::Disabled);
+    Number::normalize(negative, mantissa, exponent, minMantissa, maxMantissa);
 
     auto const sign = negative ? -1 : 1;
     return std::make_pair(static_cast<T>(sign * mantissa), exponent);
@@ -858,8 +763,6 @@ to_string(MantissaRange::MantissaScale const& scale)
     {
         case MantissaRange::MantissaScale::Small:
             return "small";
-        case MantissaRange::MantissaScale::LargeLegacy:
-            return "largeLegacy";
         case MantissaRange::MantissaScale::Large:
             return "large";
         default:

include/xrpl/basics/SHAMapHash.h

@@ -21,12 +21,12 @@ public:
     }
 
     [[nodiscard]] uint256 const&
-    asUInt256() const
+    asUint256() const
     {
         return hash_;
     }
     uint256&
-    asUInt256()
+    asUint256()
     {
         return hash_;
     }
@@ -93,7 +93,7 @@ template <>
 inline std::size_t
 extract(SHAMapHash const& key)
 {
-    return *reinterpret_cast<std::size_t const*>(key.asUInt256().data());
+    return *reinterpret_cast<std::size_t const*>(key.asUint256().data());
 }
 
 }  // namespace xrpl

include/xrpl/basics/SharedWeakCachePointer.ipp

@@ -57,10 +57,10 @@ template <class T>
 std::shared_ptr<T> const&
 SharedWeakCachePointer<T>::getStrong() const
 {
-    static std::shared_ptr<T> const kEmpty;
+    static std::shared_ptr<T> const kEMPTY;
     if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
         return *p;
-    return kEmpty;
+    return kEMPTY;
 }
 
 template <class T>

include/xrpl/basics/Slice.h

@@ -11,7 +11,6 @@
 #include <limits>
 #include <stdexcept>
 #include <string>
-#include <string_view>
 #include <type_traits>
 #include <vector>
 
@@ -232,11 +231,4 @@ makeSlice(std::basic_string<char, Traits, Alloc> const& s)
     return Slice(s.data(), s.size());
 }
 
-template <class Traits>
-Slice
-makeSlice(std::basic_string_view<char, Traits> s)
-{
-    return Slice(s.data(), s.size());
-}
-
 }  // namespace xrpl

include/xrpl/basics/StringUtilities.h

@@ -7,11 +7,9 @@
 #include <boost/utility/string_view.hpp>
 
 #include <array>
-#include <concepts>
 #include <cstdint>
 #include <optional>
 #include <string>
-#include <type_traits>
 
 namespace xrpl {
 
@@ -28,39 +26,28 @@ namespace xrpl {
 std::string
 sqlBlobLiteral(Blob const& blob);
 
-namespace detail {
-
-template <typename T>
-concept SomeChar = std::same_as<std::remove_cvref_t<T>, int8_t> ||
-    std::same_as<std::remove_cvref_t<T>, char> || std::same_as<std::remove_cvref_t<T>, uint8_t>;
-
-inline constexpr std::array<std::optional<int>, 256> const kDigitLookupTable = []() {
-    std::array<std::optional<int>, 256> t{};
-
-    for (int i = 0; i < 10; ++i)
-        t['0' + i] = i;
-
-    for (int i = 0; i < 6; ++i)
-    {
-        t['A' + i] = 10 + i;
-        t['a' + i] = 10 + i;
-    }
-
-    return t;
-}();
-
-inline std::optional<int>
-hexCharToInt(SomeChar auto hexChar)
-{
-    return kDigitLookupTable[static_cast<uint8_t>(hexChar)];
-}
-
-}  // namespace detail
-
 template <class Iterator>
 std::optional<Blob>
 strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 {
+    static constexpr std::array<int, 256> const kDIGIT_LOOKUP_TABLE = []() {
+        std::array<int, 256> t{};
+
+        for (auto& x : t)
+            x = -1;
+
+        for (int i = 0; i < 10; ++i)
+            t['0' + i] = i;
+
+        for (int i = 0; i < 6; ++i)
+        {
+            t['A' + i] = 10 + i;
+            t['a' + i] = 10 + i;
+        }
+
+        return t;
+    }();
+
     Blob out;
 
     out.reserve((strSize + 1) / 2);
@@ -69,26 +56,27 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     if (strSize & 1)
     {
-        auto const c = detail::hexCharToInt(*iter++);
-        if (!c.has_value())
+        int c = kDIGIT_LOOKUP_TABLE[*iter++];
+
+        if (c < 0)
             return {};
 
-        out.push_back(static_cast<unsigned char>(*c));
+        out.push_back(c);
     }
 
     while (iter != end)
     {
-        auto const cHigh = detail::hexCharToInt(*iter++);
+        int const cHigh = kDIGIT_LOOKUP_TABLE[*iter++];
 
-        if (!cHigh.has_value())
+        if (cHigh < 0)
             return {};
 
-        auto const cLow = detail::hexCharToInt(*iter++);
+        int const cLow = kDIGIT_LOOKUP_TABLE[*iter++];
 
-        if (!cLow.has_value())
+        if (cLow < 0)
             return {};
 
-        out.push_back(static_cast<unsigned char>((*cHigh << 4) | *cLow));
+        out.push_back(static_cast<unsigned char>((cHigh << 4) | cLow));
     }
 
     return {std::move(out)};
@@ -132,7 +120,7 @@ std::string
 trimWhitespace(std::string str);
 
 std::optional<std::uint64_t>
-toUInt64(std::string const& s);
+toUint64(std::string const& s);
 
 /** Determines if the given string looks like a TOML-file hosting domain.
 

include/xrpl/basics/StructuredLogging.h

@@ -0,0 +1,320 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#include <concepts>
+#include <iterator>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+namespace xrpl {
+
+namespace detail {
+
+/**
+ * @brief Concept that detects whether @c to_string(t) is a valid expression
+ * returning something convertible to @c std::string.
+ *
+ * Because this concept lives inside @c namespace @c xrpl, unqualified lookup
+ * will find every @c xrpl::to_string overload (e.g. for @c Number,
+ * @c Currency, @c AccountID, @c XRPAmount, @c IOUAmount, @c Asset, etc.).
+ * ADL further extends the search to any namespace associated with @p T.
+ */
+template <typename T>
+concept HasToString = requires(std::remove_cvref_t<T> const& t) {
+    { to_string(t) } -> std::convertible_to<std::string>;
+};
+
+/**
+ * @brief Escape a string for safe embedding in a JSON value.
+ *
+ * Escapes backslash, double-quote, and control characters (U+0000-U+001F)
+ * according to RFC 8259 section 7.
+ */
+inline void
+appendEscapedJsonString(std::string& dest, std::string_view sv)
+{
+    dest.reserve(dest.size() + sv.size() + 2);
+    dest += '"';
+    for (char const c : sv)
+    {
+        switch (c)
+        {
+            case '"':
+                dest += "\\\"";
+                break;
+            case '\\':
+                dest += "\\\\";
+                break;
+            case '\b':
+                dest += "\\b";
+                break;
+            case '\f':
+                dest += "\\f";
+                break;
+            case '\n':
+                dest += "\\n";
+                break;
+            case '\r':
+                dest += "\\r";
+                break;
+            case '\t':
+                dest += "\\t";
+                break;
+            default:
+                if (static_cast<unsigned char>(c) < 0x20)
+                {
+                    fmt::format_to(
+                        std::back_inserter(dest), "\\u{:04x}", static_cast<unsigned int>(c));
+                }
+                else
+                {
+                    dest += c;
+                }
+                break;
+        }
+    }
+    dest += '"';
+}
+
+/**
+ * @brief Append a value formatted as a JSON fragment to @p dest.
+ *
+ * - @c bool \u2192 unquoted @c true / @c false
+ * - integral (non-bool) \u2192 unquoted number
+ * - floating-point \u2192 unquoted number
+ * - types with @c to_string \u2192 quoted string via @c to_string
+ * - everything else \u2192 quoted string obtained via @c fmt::format
+ *
+ * @tparam T The value type.
+ * @param dest The string to append the JSON fragment to.
+ * @param value The value to format.
+ */
+template <typename T>
+void
+appendJsonValue(std::string& dest, T const& value)
+{
+    if constexpr (std::is_same_v<T, bool>)
+    {
+        dest += value ? "true" : "false";
+    }
+    else if constexpr (std::is_integral_v<T>)
+    {
+        dest += std::to_string(value);
+    }
+    else if constexpr (std::is_floating_point_v<T>)
+    {
+        dest += std::to_string(value);
+    }
+    else if constexpr (HasToString<T>)
+    {
+        appendEscapedJsonString(dest, to_string(value));
+    }
+    else
+    {
+        appendEscapedJsonString(dest, fmt::format("{}", value));
+    }
+}
+
+/**
+ * @brief Append a @c "key":value JSON field to @p dest.
+ *
+ * Inserts a comma separator when @p dest already contains fields.
+ * The value is formatted by @ref appendJsonValue.
+ */
+template <typename T>
+void
+appendJsonField(std::string& dest, std::string_view key, T const& value)
+{
+    if (!dest.empty())
+        dest += ',';
+    appendEscapedJsonString(dest, key);
+    dest += ':';
+    appendJsonValue(dest, value);
+}
+
+/**
+ * @brief Append a @c key=value plain-text field to @p dest.
+ *
+ * Inserts a space separator when @p dest already contains fields.
+ */
+template <typename T>
+void
+appendTextField(std::string& dest, std::string_view key, T const& value)
+{
+    if (!dest.empty())
+        dest += ' ';
+    if constexpr (HasToString<T>)
+    {
+        fmt::format_to(std::back_inserter(dest), "{}={}", key, to_string(value));
+    }
+    else
+    {
+        fmt::format_to(std::back_inserter(dest), "{}={}", key, value);
+    }
+}
+
+/** @brief Internal builder used by @ref buildJsonPattern.
+ *
+ *  Not part of the public API — use @ref buildJsonPattern instead.
+ */
+class JsonLoggingPatternBuilder
+{
+    std::string fields_;
+
+    static constexpr std::string_view kMESSAGE_FIELD = "\"message\": %v";
+
+    static std::string
+    extractFields(std::string_view pattern)
+    {
+        if (!pattern.empty() && pattern.front() == '{')
+            pattern.remove_prefix(1);
+        // Strip the trailing message field: `"message": %v }` or `"message": %v }`
+        if (auto pos = pattern.rfind(kMESSAGE_FIELD); pos != std::string_view::npos)
+        {
+            // Also strip the leading ", " separator if present
+            auto end = pos;
+            if (end >= 2 && pattern.substr(end - 2, 2) == ", ")
+                end -= 2;
+            pattern = pattern.substr(0, end);
+        }
+        return std::string(pattern);
+    }
+
+public:
+    JsonLoggingPatternBuilder() = default;
+
+    explicit JsonLoggingPatternBuilder(std::string_view existingPattern)
+        : fields_(extractFields(existingPattern))
+    {
+    }
+
+    /** @brief Add a field. Delegates to @ref appendJsonField. */
+    template <typename T>
+    JsonLoggingPatternBuilder&
+    add(std::string_view key, T const& value)
+    {
+        appendJsonField(fields_, key, value);
+        return *this;
+    }
+
+    [[nodiscard]] std::string
+    build() const
+    {
+        std::string result = "{";
+        result += fields_;
+        if (!fields_.empty())
+            result += ", ";
+        result += kMESSAGE_FIELD;
+        result += " }";
+        return result;
+    }
+};
+
+}  // namespace detail
+
+namespace log {
+
+/**
+ * @brief Holds a named log parameter with its value.
+ *
+ * Constructed via the @ref param helper function. Designed to be passed
+ * into Logger::Pump (the integration with Pump will be added later).
+ *
+ * @tparam T The value type.
+ */
+template <typename T>
+class Parameter
+{
+    std::string name_;
+    T value_;
+
+public:
+    Parameter(std::string_view name, T value) : name_(name), value_(std::move(value))
+    {
+    }
+
+    /** @brief Get the parameter name. */
+    [[nodiscard]] std::string_view
+    name() const
+    {
+        return name_;
+    }
+
+    /** @brief Get the parameter value. */
+    [[nodiscard]] T const&
+    value() const&
+    {
+        return value_;
+    }
+
+    /** @brief Get the parameter value. */
+    [[nodiscard]] T&
+    value() &
+    {
+        return value_;
+    }
+
+    /** @brief Get the parameter value. */
+    [[nodiscard]] T&&
+    value() &&
+    {
+        return std::move(value_);
+    }
+};
+
+/**
+ * @brief Create a named log parameter.
+ *
+ * @tparam T The value type (deduced).
+ * @param name The parameter name (JSON key).
+ * @param value The parameter value.
+ * @return A Parameter holding the name and value.
+ */
+template <typename T>
+[[nodiscard]] Parameter<std::decay_t<T>>
+param(std::string_view name, T&& value)
+{
+    return Parameter<std::decay_t<T>>{name, value};
+}
+
+}  // namespace log
+
+/**
+ * @brief Build or extend a JSON log pattern from @ref log::Parameter objects.
+ *
+ * Each parameter's name becomes a JSON key and its value becomes the
+ * corresponding JSON value in the spdlog pattern string.  String-like
+ * values are treated as spdlog pattern flags (e.g. @c "%%n", @c "%%l");
+ * numeric and boolean values are embedded as literals.
+ *
+ * @code
+ *     // Build from scratch (empty existing pattern)
+ *     auto pattern = buildJsonPattern("",
+ *         log::param("channel", std::string_view("%n")),
+ *         log::param("level",   std::string_view("%l")));
+ *
+ *     // Extend an existing pattern with extra fields
+ *     auto extended = buildJsonPattern(pattern,
+ *         log::param("trace_id", traceId));
+ * @endcode
+ *
+ * @tparam Ts  Value types of the parameters.
+ * @param existingPattern  A pattern previously produced by build() or an
+ *                         empty string to start fresh.
+ * @param params  The parameters to add as JSON fields.
+ * @return The spdlog-compatible JSON pattern string.
+ */
+template <typename... Ts>
+[[nodiscard]] std::string
+buildJsonPattern(std::string_view existingPattern, log::Parameter<Ts> const&... params)
+{
+    // NOLINTNEXTLINE(misc-const-correctness)
+    detail::JsonLoggingPatternBuilder builder(existingPattern);
+    (builder.add(params.name(), params.value()), ...);
+    return builder.build();
+}
+
+}  // namespace xrpl

include/xrpl/basics/TaggedCache.h

@@ -157,7 +157,7 @@ public:
     /** Fetch an item from the cache.
         If the digest was not found, Handler
         will be called with this signature:
-            SLE::const_pointer(void)
+            std::shared_ptr<SLE const>(void)
     */
     template <class Handler>
     SharedPointerType
@@ -181,14 +181,14 @@ private:
             beast::insight::Collector::ptr const& collector)
             : hook(collector->makeHook(handler))
             , size(collector->makeGauge(prefix, "size"))
-            , hitRate(collector->makeGauge(prefix, "hit_rate"))
+            , hit_rate(collector->makeGauge(prefix, "hit_rate"))
 
         {
         }
 
         beast::insight::Hook hook;
         beast::insight::Gauge size;
-        beast::insight::Gauge hitRate;
+        beast::insight::Gauge hit_rate;
 
         std::size_t hits{0};
         std::size_t misses{0};
@@ -197,16 +197,16 @@ private:
     class KeyOnlyEntry
     {
     public:
-        clock_type::time_point lastAccess;
+        clock_type::time_point last_access;
 
-        explicit KeyOnlyEntry(clock_type::time_point const& lastAccess) : lastAccess(lastAccess)
+        explicit KeyOnlyEntry(clock_type::time_point const& lastAccess) : last_access(lastAccess)
         {
         }
 
         void
         touch(clock_type::time_point const& now)
         {
-            lastAccess = now;
+            last_access = now;
         }
     };
 
@@ -214,10 +214,10 @@ private:
     {
     public:
         shared_weak_combo_pointer_type ptr;
-        clock_type::time_point lastAccess;
+        clock_type::time_point last_access;
 
         ValueEntry(clock_type::time_point const& lastAccess, shared_pointer_type const& ptr)
-            : ptr(ptr), lastAccess(lastAccess)
+            : ptr(ptr), last_access(lastAccess)
         {
         }
 
@@ -246,7 +246,7 @@ private:
         void
         touch(clock_type::time_point const& now)
         {
-            lastAccess = now;
+            last_access = now;
         }
     };
 
@@ -286,13 +286,13 @@ private:
     std::string name_;
 
     // Desired number of cache entries (0 = ignore)
-    int const targetSize_;
+    int const target_size_;
 
     // Desired maximum cache age
-    clock_type::duration const targetAge_;
+    clock_type::duration const target_age_;
 
     // Number of items cached
-    int cacheCount_{0};
+    int cache_count_{0};
     cache_type cache_;  // Hold strong reference to recent objects
     std::uint64_t hits_{0};
     std::uint64_t misses_{0};

include/xrpl/basics/TaggedCache.ipp

@@ -34,8 +34,8 @@ inline TaggedCache<
     , clock_(clock)
     , stats_(name, std::bind(&TaggedCache::collectMetrics, this), collector)
     , name_(name)
-    , targetSize_(size)
-    , targetAge_(expiration)
+    , target_size_(size)
+    , target_age_(expiration)
 {
 }
 
@@ -86,7 +86,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     getCacheSize() const
 {
     std::scoped_lock const lock(mutex_);
-    return cacheCount_;
+    return cache_count_;
 }
 
 template <
@@ -139,7 +139,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 {
     std::scoped_lock const lock(mutex_);
     cache_.clear();
-    cacheCount_ = 0;
+    cache_count_ = 0;
 }
 
 template <
@@ -157,7 +157,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 {
     std::scoped_lock const lock(mutex_);
     cache_.clear();
-    cacheCount_ = 0;
+    cache_count_ = 0;
     hits_ = 0;
     misses_ = 0;
 }
@@ -213,21 +213,21 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     {
         std::scoped_lock const lock(mutex_);
 
-        if (targetSize_ == 0 || (static_cast<int>(cache_.size()) <= targetSize_))
+        if (target_size_ == 0 || (static_cast<int>(cache_.size()) <= target_size_))
         {
-            whenExpire = now - targetAge_;
+            whenExpire = now - target_age_;
         }
         else
         {
-            whenExpire = now - (targetAge_ * targetSize_ / cache_.size());
+            whenExpire = now - (target_age_ * target_size_ / cache_.size());
 
             clock_type::duration const minimumAge(std::chrono::seconds(1));
             if (whenExpire > (now - minimumAge))
                 whenExpire = now - minimumAge;
 
             JLOG(journal_.trace())
-                << name_ << " is growing fast " << cache_.size() << " of " << targetSize_
-                << " aging at " << (now - whenExpire).count() << " of " << targetAge_.count();
+                << name_ << " is growing fast " << cache_.size() << " of " << target_size_
+                << " aging at " << (now - whenExpire).count() << " of " << target_age_.count();
         }
 
         std::vector<std::thread> workers;
@@ -242,7 +242,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
         for (std::thread& worker : workers)
             worker.join();
 
-        cacheCount_ -= allRemovals;
+        cache_count_ -= allRemovals;
     }
     // At this point allStuffToSweep will go out of scope outside the lock
     // and decrement the reference count on each strong pointer.
@@ -280,7 +280,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
     if (entry.isCached())
     {
-        --cacheCount_;
+        --cache_count_;
         entry.ptr.convertToWeak();
         ret = true;
     }
@@ -317,7 +317,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
             std::piecewise_construct,
             std::forward_as_tuple(key),
             std::forward_as_tuple(clock_.now(), data));
-        ++cacheCount_;
+        ++cache_count_;
         return false;
     }
 
@@ -366,12 +366,12 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
             data = cachedData;
         }
 
-        ++cacheCount_;
+        ++cache_count_;
         return true;
     }
 
     entry.ptr = data;
-    ++cacheCount_;
+    ++cache_count_;
 
     return false;
 }
@@ -477,7 +477,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     auto [it, inserted] = cache_.emplace(
         std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
     if (!inserted)
-        it->second.lastAccess = now;
+        it->second.last_access = now;
     return inserted;
 }
 
@@ -626,7 +626,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     if (entry.isCached())
     {
         // independent of cache size, so not counted as a hit
-        ++cacheCount_;
+        ++cache_count_;
         entry.touch(clock_.now());
         return entry.ptr.getStrong();
     }
@@ -658,7 +658,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
             if (total != 0)
                 hitRate = (hits_ * 100) / total;
         }
-        stats_.hitRate.set(hitRate);
+        stats_.hit_rate.set(hitRate);
     }
 }
 
@@ -706,7 +706,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
                         ++cit;
                     }
                 }
-                else if (cit->second.lastAccess <= whenExpire)
+                else if (cit->second.last_access <= whenExpire)
                 {
                     // strong, expired
                     ++cacheRemovals;
@@ -773,12 +773,12 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
             auto cit = partition.begin();
             while (cit != partition.end())
             {
-                if (cit->second.lastAccess > now)
+                if (cit->second.last_access > now)
                 {
-                    cit->second.lastAccess = now;
+                    cit->second.last_access = now;
                     ++cit;
                 }
-                else if (cit->second.lastAccess <= whenExpire)
+                else if (cit->second.last_access <= whenExpire)
                 {
                     cit = partition.erase(cit);
                 }

include/xrpl/basics/UptimeClock.h

@@ -30,8 +30,8 @@ public:
     now();  // seconds since xrpld program start
 
 private:
-    static std::atomic<rep> kNow;
-    static std::atomic<bool> kStop;
+    static std::atomic<rep> kNOW;
+    static std::atomic<bool> kSTOP;
 
     struct UpdateThread : private std::thread
     {

include/xrpl/basics/base_uint.h

@@ -46,11 +46,6 @@ struct IsContiguousContainer<Slice> : std::true_type
 {
 };
 
-template <typename...>
-struct AlwaysFalseT : std::bool_constant<false>
-{
-};
-
 }  // namespace detail
 
 /** Integers of any length that is a multiple of 32-bits
@@ -67,18 +62,18 @@ struct AlwaysFalseT : std::bool_constant<false>
                       number of bits.
  */
 template <std::size_t Bits, class Tag = void>
-class BaseUInt
+class BaseUint
 {
     static_assert((Bits % 32) == 0, "The length of a base_uint in bits must be a multiple of 32.");
 
     static_assert(Bits >= 64, "The length of a base_uint in bits must be at least 64.");
 
-    static constexpr std::size_t kWidth = Bits / 32;
+    static constexpr std::size_t kWIDTH = Bits / 32;
 
     // This is really big-endian in byte order.
     // We sometimes use std::uint32_t for speed.
 
-    std::array<std::uint32_t, kWidth> data_;
+    std::array<std::uint32_t, kWIDTH> data_;
 
 public:
     //--------------------------------------------------------------------------
@@ -86,8 +81,8 @@ public:
     // STL Container Interface
     //
 
-    static constexpr std::size_t kBytes = Bits / 8;
-    static_assert(sizeof(data_) == kBytes, "");
+    static std::size_t constexpr kBYTES = Bits / 8;
+    static_assert(sizeof(data_) == kBYTES, "");
 
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
@@ -121,7 +116,7 @@ public:
     iterator
     end()
     {
-        return data() + kBytes;
+        return data() + kBYTES;
     }
     [[nodiscard]] const_iterator
     begin() const
@@ -131,7 +126,7 @@ public:
     [[nodiscard]] const_iterator
     end() const
     {
-        return data() + kBytes;
+        return data() + kBYTES;
     }
     [[nodiscard]] const_iterator
     cbegin() const
@@ -141,7 +136,7 @@ public:
     [[nodiscard]] const_iterator
     cend() const
     {
-        return data() + kBytes;
+        return data() + kBYTES;
     }
 
     /** Value hashing function.
@@ -165,9 +160,9 @@ private:
         explicit VoidHelper() = default;
     };
 
-    explicit BaseUInt(void const* data, VoidHelper)
+    explicit BaseUint(void const* data, VoidHelper)
     {
-        memcpy(data_.data(), data, kBytes);
+        memcpy(data_.data(), data, kBYTES);
     }
 
     // Helper function to initialize a base_uint from a std::string_view.
@@ -249,15 +244,15 @@ private:
     }
 
 public:
-    constexpr BaseUInt() : data_{}
+    constexpr BaseUint() : data_{}
     {
     }
 
-    constexpr BaseUInt(beast::Zero) : data_{}
+    constexpr BaseUint(beast::Zero) : data_{}
     {
     }
 
-    explicit BaseUInt(std::uint64_t b)
+    explicit BaseUint(std::uint64_t b)
     {
         *this = b;
     }
@@ -265,7 +260,7 @@ 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 BaseUInt(std::string_view sv) noexcept(false)
+    explicit constexpr BaseUint(std::string_view sv) noexcept(false)
         : data_(parseFromStringViewThrows(sv))
     {
     }
@@ -275,42 +270,24 @@ public:
         class = std::enable_if_t<
             detail::IsContiguousContainer<Container>::value &&
             std::is_trivially_copyable_v<typename Container::value_type>>>
-    explicit BaseUInt(Container const& c)
+    explicit BaseUint(Container const& c)
     {
-        // Use AlwaysFalseT so the static_assert condition is dependent
-        // and only triggers when this constructor template is instantiated.
-        static_assert(
-            detail::AlwaysFalseT<Container>::value,
-            "This constructor is not intended to be used and will be soon removed. "
-            "Use base_uint::fromRaw instead.");
-    }
-
-    template <
-        class Container,
-        class = std::enable_if_t<
-            detail::IsContiguousContainer<Container>::value &&
-            std::is_trivially_copyable_v<typename Container::value_type>>>
-    static BaseUInt
-    fromRaw(Container const& c)
-    {
-        BaseUInt result;
         XRPL_ASSERT(
             c.size() * sizeof(typename Container::value_type) == size(),
-            "xrpl::BaseUInt::fromRaw(Container auto) : input size match");
-        std::memcpy(result.data_.data(), c.data(), size());
-        return result;
+            "xrpl::base_uint::base_uint(Container auto) : input size match");
+        std::memcpy(data_.data(), c.data(), size());
     }
 
     template <class Container>
     std::enable_if_t<
         detail::IsContiguousContainer<Container>::value &&
             std::is_trivially_copyable_v<typename Container::value_type>,
-        BaseUInt&>
+        BaseUint&>
     operator=(Container const& c)
     {
         XRPL_ASSERT(
             c.size() * sizeof(typename Container::value_type) == size(),
-            "xrpl::BaseUInt::operator=(Container auto) : input size match");
+            "xrpl::base_uint::operator=(Container auto) : input size match");
         std::memcpy(data_.data(), c.data(), size());
         return *this;
     }
@@ -318,14 +295,14 @@ public:
     /* Construct from a raw pointer.
         The buffer pointed to by `data` must be at least Bits/8 bytes.
     */
-    static BaseUInt
+    static BaseUint
     fromVoid(void const* data)
     {
-        return BaseUInt(data, VoidHelper());
+        return BaseUint(data, VoidHelper());
     }
 
     template <class T>
-    static std::optional<BaseUInt>
+    static std::optional<BaseUint>
     fromVoidChecked(T const& from)
     {
         if (from.size() != size())
@@ -336,7 +313,7 @@ public:
     [[nodiscard]] constexpr int
     signum() const
     {
-        for (int i = 0; i < kWidth; i++)
+        for (int i = 0; i < kWIDTH; i++)
         {
             if (data_[i] != 0)
                 return 1;
@@ -348,24 +325,24 @@ public:
     bool
     operator!() const
     {
-        return *this == beast::kZero;
+        return *this == beast::kZERO;
     }
 
-    constexpr BaseUInt
+    constexpr BaseUint
     operator~() const
     {
-        BaseUInt ret;
+        BaseUint ret;
 
-        for (int i = 0; i < kWidth; i++)
+        for (int i = 0; i < kWIDTH; i++)
             ret.data_[i] = ~data_[i];
 
         return ret;
     }
 
-    BaseUInt&
+    BaseUint&
     operator=(std::uint64_t uHost)
     {
-        *this = beast::kZero;
+        *this = beast::kZERO;
         // NOLINTBEGIN(cppcoreguidelines-pro-type-member-init)
         union
         {
@@ -375,43 +352,43 @@ public:
         // NOLINTEND(cppcoreguidelines-pro-type-member-init)
         // Put in least significant bits.
         ul = boost::endian::native_to_big(uHost);
-        data_[kWidth - 2] = u[0];
-        data_[kWidth - 1] = u[1];
+        data_[kWIDTH - 2] = u[0];
+        data_[kWIDTH - 1] = u[1];
         return *this;
     }
 
-    BaseUInt&
-    operator^=(BaseUInt const& b)
+    BaseUint&
+    operator^=(BaseUint const& b)
     {
-        for (int i = 0; i < kWidth; i++)
+        for (int i = 0; i < kWIDTH; i++)
             data_[i] ^= b.data_[i];
 
         return *this;
     }
 
-    BaseUInt&
-    operator&=(BaseUInt const& b)
+    BaseUint&
+    operator&=(BaseUint const& b)
     {
-        for (int i = 0; i < kWidth; i++)
+        for (int i = 0; i < kWIDTH; i++)
             data_[i] &= b.data_[i];
 
         return *this;
     }
 
-    BaseUInt&
-    operator|=(BaseUInt const& b)
+    BaseUint&
+    operator|=(BaseUint const& b)
     {
-        for (int i = 0; i < kWidth; i++)
+        for (int i = 0; i < kWIDTH; i++)
             data_[i] |= b.data_[i];
 
         return *this;
     }
 
-    BaseUInt&
+    BaseUint&
     operator++()
     {
         // prefix operator
-        for (int i = kWidth - 1; i >= 0; --i)
+        for (int i = kWIDTH - 1; i >= 0; --i)
         {
             data_[i] = boost::endian::native_to_big(boost::endian::big_to_native(data_[i]) + 1);
             if (data_[i] != 0)
@@ -421,20 +398,20 @@ public:
         return *this;
     }
 
-    BaseUInt
+    BaseUint
     operator++(int)
     {
         // postfix operator
-        BaseUInt const ret = *this;
+        BaseUint const ret = *this;
         ++(*this);
 
         return ret;
     }
 
-    BaseUInt&
+    BaseUint&
     operator--()
     {
-        for (int i = kWidth - 1; i >= 0; --i)
+        for (int i = kWIDTH - 1; i >= 0; --i)
         {
             auto prev = data_[i];
             data_[i] = boost::endian::native_to_big(boost::endian::big_to_native(data_[i]) - 1);
@@ -446,36 +423,36 @@ public:
         return *this;
     }
 
-    BaseUInt
+    BaseUint
     operator--(int)
     {
         // postfix operator
-        BaseUInt const ret = *this;
+        BaseUint const ret = *this;
         --(*this);
 
         return ret;
     }
 
-    [[nodiscard]] BaseUInt
+    [[nodiscard]] BaseUint
     next() const
     {
         auto ret = *this;
         return ++ret;
     }
 
-    [[nodiscard]] BaseUInt
+    [[nodiscard]] BaseUint
     prev() const
     {
         auto ret = *this;
         return --ret;
     }
 
-    BaseUInt&
-    operator+=(BaseUInt const& b)
+    BaseUint&
+    operator+=(BaseUint const& b)
     {
         std::uint64_t carry = 0;
 
-        for (int i = kWidth - 1; i >= 0; i--)
+        for (int i = kWIDTH - 1; i >= 0; i--)
         {
             std::uint64_t const n = carry + boost::endian::big_to_native(data_[i]) +
                 boost::endian::big_to_native(b.data_[i]);
@@ -489,7 +466,7 @@ public:
 
     template <class Hasher>
     friend void
-    hash_append(Hasher& h, BaseUInt const& a) noexcept
+    hash_append(Hasher& h, BaseUint const& a) noexcept
     {
         // Do not allow any endian transformations on this memory
         h(a.data_.data(), sizeof(a.data_));
@@ -526,13 +503,13 @@ public:
         return parseHex(std::string_view{str});
     }
 
-    static constexpr std::size_t
+    constexpr static std::size_t
     size()
     {
-        return kBytes;
+        return kBYTES;
     }
 
-    BaseUInt<Bits, Tag>&
+    BaseUint<Bits, Tag>&
     operator=(beast::Zero)
     {
         data_.fill(0);
@@ -543,28 +520,28 @@ public:
     [[nodiscard]] bool
     isZero() const
     {
-        return *this == beast::kZero;
+        return *this == beast::kZERO;
     }
     [[nodiscard]] bool
     isNonZero() const
     {
-        return *this != beast::kZero;
+        return *this != beast::kZERO;
     }
     void
     zero()
     {
-        *this = beast::kZero;
+        *this = beast::kZERO;
     }
 };
 
-using uint128 = BaseUInt<128>;
-using uint160 = BaseUInt<160>;
-using uint256 = BaseUInt<256>;
-using uint192 = BaseUInt<192>;
+using uint128 = BaseUint<128>;
+using uint160 = BaseUint<160>;
+using uint256 = BaseUint<256>;
+using uint192 = BaseUint<192>;
 
 template <std::size_t Bits, class Tag>
 [[nodiscard]] constexpr std::strong_ordering
-operator<=>(BaseUInt<Bits, Tag> const& lhs, BaseUInt<Bits, Tag> const& rhs)
+operator<=>(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
 {
     // This comparison might seem wrong on a casual inspection because it
     // compares data internally stored as std::uint32_t byte-by-byte. But
@@ -585,7 +562,7 @@ operator<=>(BaseUInt<Bits, Tag> const& lhs, BaseUInt<Bits, Tag> const& rhs)
 
 template <std::size_t Bits, typename Tag>
 [[nodiscard]] constexpr bool
-operator==(BaseUInt<Bits, Tag> const& lhs, BaseUInt<Bits, Tag> const& rhs)
+operator==(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
 {
     return (lhs <=> rhs) == 0;
 }
@@ -593,59 +570,59 @@ operator==(BaseUInt<Bits, Tag> const& lhs, BaseUInt<Bits, Tag> const& rhs)
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
 constexpr bool
-operator==(BaseUInt<Bits, Tag> const& a, std::uint64_t b)
+operator==(BaseUint<Bits, Tag> const& a, std::uint64_t b)
 {
-    return a == BaseUInt<Bits, Tag>(b);
+    return a == BaseUint<Bits, Tag>(b);
 }
 
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
-constexpr BaseUInt<Bits, Tag>
-operator^(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
+constexpr BaseUint<Bits, Tag>
+operator^(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
 {
-    return BaseUInt<Bits, Tag>(a) ^= b;
+    return BaseUint<Bits, Tag>(a) ^= b;
 }
 
 template <std::size_t Bits, class Tag>
-constexpr BaseUInt<Bits, Tag>
-operator&(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
+constexpr BaseUint<Bits, Tag>
+operator&(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
 {
-    return BaseUInt<Bits, Tag>(a) &= b;
+    return BaseUint<Bits, Tag>(a) &= b;
 }
 
 template <std::size_t Bits, class Tag>
-constexpr BaseUInt<Bits, Tag>
-operator|(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
+constexpr BaseUint<Bits, Tag>
+operator|(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
 {
-    return BaseUInt<Bits, Tag>(a) |= b;
+    return BaseUint<Bits, Tag>(a) |= b;
 }
 
 template <std::size_t Bits, class Tag>
-constexpr BaseUInt<Bits, Tag>
-operator+(BaseUInt<Bits, Tag> const& a, BaseUInt<Bits, Tag> const& b)
+constexpr BaseUint<Bits, Tag>
+operator+(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
 {
-    return BaseUInt<Bits, Tag>(a) += b;
+    return BaseUint<Bits, Tag>(a) += b;
 }
 
 //------------------------------------------------------------------------------
 template <std::size_t Bits, class Tag>
 inline std::string
-to_string(BaseUInt<Bits, Tag> const& a)
+to_string(BaseUint<Bits, Tag> const& a)
 {
     return strHex(a.cbegin(), a.cend());
 }
 
 template <std::size_t Bits, class Tag>
 inline std::string
-toShortString(BaseUInt<Bits, Tag> const& a)
+toShortString(BaseUint<Bits, Tag> const& a)
 {
-    static_assert(BaseUInt<Bits, Tag>::kBytes > 4, "For 4 bytes or less, use a native type");
+    static_assert(BaseUint<Bits, Tag>::kBYTES > 4, "For 4 bytes or less, use a native type");
     return strHex(a.cbegin(), a.cbegin() + 4) + "...";
 }
 
 template <std::size_t Bits, class Tag>
 inline std::ostream&
-operator<<(std::ostream& out, BaseUInt<Bits, Tag> const& u)
+operator<<(std::ostream& out, BaseUint<Bits, Tag> const& u)
 {
     return out << to_string(u);
 }
@@ -673,7 +650,7 @@ static_assert(sizeof(uint256) == 256 / 8, "There should be no padding bytes");
 namespace beast {
 
 template <std::size_t Bits, class Tag>
-struct IsUniquelyRepresented<xrpl::BaseUInt<Bits, Tag>> : public std::true_type
+struct IsUniquelyRepresented<xrpl::BaseUint<Bits, Tag>> : public std::true_type
 {
     explicit IsUniquelyRepresented() = default;
 };

include/xrpl/basics/chrono.h

@@ -30,10 +30,10 @@ using weeks = std::chrono::duration<int, std::ratio_multiply<days::period, std::
     = seconds(946684800)
 */
 
-static constexpr std::chrono::seconds kEpochOffset =
+constexpr static std::chrono::seconds kEPOCH_OFFSET =
     date::sys_days{date::year{2000} / 1 / 1} - date::sys_days{date::year{1970} / 1 / 1};
 
-static_assert(kEpochOffset.count() == 946684800);
+static_assert(kEPOCH_OFFSET.count() == 946684800);
 
 class NetClock
 {
@@ -60,7 +60,7 @@ to_string(NetClock::time_point tp)
 {
     // 2000-01-01 00:00:00 UTC is 946684800s from 1970-01-01 00:00:00 UTC
     using namespace std::chrono;
-    return to_string(system_clock::time_point{tp.time_since_epoch() + kEpochOffset});
+    return to_string(system_clock::time_point{tp.time_since_epoch() + kEPOCH_OFFSET});
 }
 
 template <class Duration>
@@ -77,7 +77,7 @@ toStringIso(NetClock::time_point tp)
     // 2000-01-01 00:00:00 UTC is 946684800s from 1970-01-01 00:00:00 UTC
     // Note, NetClock::duration is seconds, as checked by static_assert
     static_assert(std::is_same_v<NetClock::duration::period, std::ratio<1>>);
-    return toStringIso(date::sys_time<NetClock::duration>{tp.time_since_epoch() + kEpochOffset});
+    return toStringIso(date::sys_time<NetClock::duration>{tp.time_since_epoch() + kEPOCH_OFFSET});
 }
 
 /** A clock for measuring elapsed time.

include/xrpl/basics/hardened_hash.h

@@ -31,9 +31,9 @@ makeSeedPair() noexcept
         // state_t(state_t const&) = delete;
         // state_t& operator=(state_t const&) = delete;
     };
-    static StateT kState;
-    std::scoped_lock const lock(kState.mutex);
-    return {kState.dist(kState.gen), kState.dist(kState.gen)};
+    static StateT kSTATE;
+    std::scoped_lock const lock(kSTATE.mutex);
+    return {kSTATE.dist(kSTATE.gen), kSTATE.dist(kSTATE.gen)};
 }
 
 }  // namespace detail

include/xrpl/basics/mulDiv.h

@@ -5,7 +5,7 @@
 #include <optional>
 
 namespace xrpl {
-constexpr auto kMuldivMax = std::numeric_limits<std::uint64_t>::max();
+auto constexpr kMULDIV_MAX = std::numeric_limits<std::uint64_t>::max();
 
 /** Return value*mul/div accurately.
     Computes the result of the multiplication and division in

include/xrpl/basics/partitioned_unordered_map.h

@@ -236,7 +236,7 @@ public:
         map_.resize(partitions_);
         XRPL_ASSERT(
             partitions_,
-            "xrpl::PartitionedUnorderedMap::PartitionedUnorderedMap : "
+            "xrpl::partitioned_unordered_map::partitioned_unordered_map : "
             "nonzero partitions");
     }
 

include/xrpl/basics/random.h

@@ -47,7 +47,7 @@ inline beast::xor_shift_engine&
 defaultPrng()
 {
     // This is used to seed the thread-specific PRNGs on demand
-    static beast::xor_shift_engine kSeeder = [] {
+    static beast::xor_shift_engine kSEEDER = [] {
         std::random_device rng;
         std::uniform_int_distribution<std::uint64_t> distribution{1};
         return beast::xor_shift_engine(distribution(rng));
@@ -57,17 +57,17 @@ defaultPrng()
     static std::mutex kM;
 
     // The thread-specific PRNGs:
-    thread_local beast::xor_shift_engine kEngine = [] {
+    thread_local beast::xor_shift_engine kENGINE = [] {
         std::uint64_t seed = 0;
         {
             std::scoped_lock const lk(kM);
             std::uniform_int_distribution<std::uint64_t> distribution{1};
-            seed = distribution(kSeeder);
+            seed = distribution(kSEEDER);
         }
         return beast::xor_shift_engine{seed};
     }();
 
-    return kEngine;
+    return kENGINE;
 }
 
 /** Return a uniformly distributed random integer.
@@ -94,7 +94,7 @@ template <class Engine, class Integral>
 std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine, Integral min, Integral max)
 {
-    XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs");
+    XRPL_ASSERT(max > min, "xrpl::rand_int : max over min inputs");
 
     // This should have no state and constructing it should
     // be very cheap. If that turns out not to be the case

include/xrpl/basics/safe_cast.h

@@ -22,9 +22,9 @@ safeCast(Src s) noexcept
 {
     static_assert(
         std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
-    constexpr unsigned kNotSame = std::is_signed_v<Dest> != std::is_signed_v<Src>;
+    constexpr unsigned kNOT_SAME = std::is_signed_v<Dest> != std::is_signed_v<Src>;
     static_assert(
-        sizeof(Dest) >= sizeof(Src) + kNotSame,
+        sizeof(Dest) >= sizeof(Src) + kNOT_SAME,
         "Destination is too small to hold all values of source");
     return static_cast<Dest>(s);
 }
@@ -81,7 +81,7 @@ safeDowncast(Src* s) noexcept
     return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
 #else
     auto* result = dynamic_cast<Dest>(s);
-    XRPL_ASSERT(result != nullptr, "xrpl::safeDowncast : pointer downcast is valid");
+    XRPL_ASSERT(result != nullptr, "xrpl::safe_downcast : pointer downcast is valid");
     return result;
 #endif
 }
@@ -94,7 +94,7 @@ safeDowncast(Src& s) noexcept
 #ifndef NDEBUG
     XRPL_ASSERT(
         dynamic_cast<std::add_pointer_t<std::remove_reference_t<Dest>>>(&s) != nullptr,
-        "xrpl::safeDowncast : reference downcast is valid");
+        "xrpl::safe_downcast : reference downcast is valid");
 #endif
     return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
 }

include/xrpl/basics/scope.h

@@ -24,20 +24,20 @@ namespace xrpl {
 template <class EF>
 class ScopeExit
 {
-    EF exitFunction_;
-    bool executeOnDestruction_{true};
+    EF exit_function_;
+    bool execute_on_destruction_{true};
 
 public:
     ~ScopeExit()
     {
-        if (executeOnDestruction_)
-            exitFunction_();
+        if (execute_on_destruction_)
+            exit_function_();
     }
 
     ScopeExit(ScopeExit&& rhs) noexcept(
         std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
-        : exitFunction_{std::forward<EF>(rhs.exitFunction_)}
-        , executeOnDestruction_{rhs.executeOnDestruction_}
+        : exit_function_{std::forward<EF>(rhs.exit_function_)}
+        , execute_on_destruction_{rhs.execute_on_destruction_}
     {
         rhs.release();
     }
@@ -51,7 +51,7 @@ public:
         std::enable_if_t<
             !std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> &&
             std::is_constructible_v<EF, EFP>>* = 0) noexcept
-        : exitFunction_{std::forward<EFP>(f)}
+        : exit_function_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
     }
@@ -59,7 +59,7 @@ public:
     void
     release() noexcept
     {
-        executeOnDestruction_ = false;
+        execute_on_destruction_ = false;
     }
 };
 
@@ -69,22 +69,22 @@ ScopeExit(EF) -> ScopeExit<EF>;
 template <class EF>
 class ScopeFail
 {
-    EF exitFunction_;
-    bool executeOnDestruction_{true};
-    int uncaughtOnCreation_{std::uncaught_exceptions()};
+    EF exit_function_;
+    bool execute_on_destruction_{true};
+    int uncaught_on_creation_{std::uncaught_exceptions()};
 
 public:
     ~ScopeFail()
     {
-        if (executeOnDestruction_ && std::uncaught_exceptions() > uncaughtOnCreation_)
-            exitFunction_();
+        if (execute_on_destruction_ && std::uncaught_exceptions() > uncaught_on_creation_)
+            exit_function_();
     }
 
     ScopeFail(ScopeFail&& rhs) noexcept(
         std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
-        : exitFunction_{std::forward<EF>(rhs.exitFunction_)}
-        , executeOnDestruction_{rhs.executeOnDestruction_}
-        , uncaughtOnCreation_{rhs.uncaughtOnCreation_}
+        : exit_function_{std::forward<EF>(rhs.exit_function_)}
+        , execute_on_destruction_{rhs.execute_on_destruction_}
+        , uncaught_on_creation_{rhs.uncaught_on_creation_}
     {
         rhs.release();
     }
@@ -98,7 +98,7 @@ public:
         std::enable_if_t<
             !std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> &&
             std::is_constructible_v<EF, EFP>>* = 0) noexcept
-        : exitFunction_{std::forward<EFP>(f)}
+        : exit_function_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
     }
@@ -106,7 +106,7 @@ public:
     void
     release() noexcept
     {
-        executeOnDestruction_ = false;
+        execute_on_destruction_ = false;
     }
 };
 
@@ -116,22 +116,22 @@ ScopeFail(EF) -> ScopeFail<EF>;
 template <class EF>
 class ScopeSuccess
 {
-    EF exitFunction_;
-    bool executeOnDestruction_{true};
-    int uncaughtOnCreation_{std::uncaught_exceptions()};
+    EF exit_function_;
+    bool execute_on_destruction_{true};
+    int uncaught_on_creation_{std::uncaught_exceptions()};
 
 public:
-    ~ScopeSuccess() noexcept(noexcept(exitFunction_()))
+    ~ScopeSuccess() noexcept(noexcept(exit_function_()))
     {
-        if (executeOnDestruction_ && std::uncaught_exceptions() <= uncaughtOnCreation_)
-            exitFunction_();
+        if (execute_on_destruction_ && std::uncaught_exceptions() <= uncaught_on_creation_)
+            exit_function_();
     }
 
     ScopeSuccess(ScopeSuccess&& rhs) noexcept(
         std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
-        : exitFunction_{std::forward<EF>(rhs.exitFunction_)}
-        , executeOnDestruction_{rhs.executeOnDestruction_}
-        , uncaughtOnCreation_{rhs.uncaughtOnCreation_}
+        : exit_function_{std::forward<EF>(rhs.exit_function_)}
+        , execute_on_destruction_{rhs.execute_on_destruction_}
+        , uncaught_on_creation_{rhs.uncaught_on_creation_}
     {
         rhs.release();
     }
@@ -146,14 +146,14 @@ public:
             !std::is_same_v<std::remove_cv_t<EFP>, ScopeSuccess> &&
             std::is_constructible_v<EF, EFP>>* =
             0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
-        : exitFunction_{std::forward<EFP>(f)}
+        : exit_function_{std::forward<EFP>(f)}
     {
     }
 
     void
     release() noexcept
     {
-        executeOnDestruction_ = false;
+        execute_on_destruction_ = false;
     }
 };
 
@@ -205,7 +205,7 @@ class ScopeUnlock
 public:
     explicit ScopeUnlock(std::unique_lock<Mutex>& lock) noexcept(true) : plock_(&lock)
     {
-        XRPL_ASSERT(plock_->owns_lock(), "xrpl::ScopeUnlock::ScopeUnlock : mutex must be locked");
+        XRPL_ASSERT(plock_->owns_lock(), "xrpl::scope_unlock::scope_unlock : mutex must be locked");
         plock_->unlock();
     }
 

include/xrpl/basics/spinlock.h

@@ -103,7 +103,7 @@ public:
     {
         XRPL_ASSERT(
             index >= 0 && (mask_ != 0),
-            "xrpl::PackedSpinlock::PackedSpinlock : valid index and mask");
+            "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
     }
 
     [[nodiscard]] bool

include/xrpl/beast/asio/io_latency_probe.h

@@ -15,7 +15,7 @@ namespace beast {
 
 /** Measures handler latency on an io_context queue. */
 template <class Clock>
-class IOLatencyProbe
+class IoLatencyProbe
 {
 private:
     using duration = typename Clock::duration;
@@ -30,12 +30,12 @@ private:
     bool cancel_{false};
 
 public:
-    IOLatencyProbe(duration const& period, boost::asio::io_context& ios)
+    IoLatencyProbe(duration const& period, boost::asio::io_context& ios)
         : period_(period), ios_(ios), timer_(ios_)
     {
     }
 
-    ~IOLatencyProbe()
+    ~IoLatencyProbe()
     {
         std::unique_lock<decltype(mutex_)> lock(mutex_);
         cancel(lock, true);
@@ -85,7 +85,7 @@ public:
     {
         std::scoped_lock const lock(mutex_);
         if (cancel_)
-            throw std::logic_error("IOLatencyProbe is canceled");
+            throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
             ios_, SampleOp<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
     }
@@ -100,7 +100,7 @@ public:
     {
         std::scoped_lock const lock(mutex_);
         if (cancel_)
-            throw std::logic_error("IOLatencyProbe is canceled");
+            throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
             ios_, SampleOp<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
     }
@@ -140,18 +140,18 @@ private:
         Handler handler;
         time_point start;
         bool repeat;
-        IOLatencyProbe* probe;
+        IoLatencyProbe* probe;
 
         SampleOp(
             Handler const& handler,
             time_point const& start,
             bool repeat,
-            IOLatencyProbe* probe)
+            IoLatencyProbe* probe)
             : handler(handler), start(start), repeat(repeat), probe(probe)
         {
             XRPL_ASSERT(
                 probe,
-                "beast::IOLatencyProbe::SampleOp::SampleOp : non-null "
+                "beast::io_latency_probe::sample_op::sample_op : non-null "
                 "probe input");
             probe->addref();
         }
@@ -164,7 +164,7 @@ private:
         {
             XRPL_ASSERT(
                 probe,
-                "beast::IOLatencyProbe::SampleOp::SampleOp(SampleOp&&) : "
+                "beast::io_latency_probe::sample_op::sample_op(sample_op&&) : "
                 "non-null probe input");
             from.probe = nullptr;
         }

include/xrpl/beast/clock/abstract_clock.h

@@ -83,8 +83,8 @@ template <class Facade, class Clock = Facade>
 AbstractClock<Facade>&
 getAbstractClock()
 {
-    static detail::AbstractClockWrapper<Facade, Clock> kClock;
-    return kClock;
+    static detail::AbstractClockWrapper<Facade, Clock> kCLOCK;
+    return kCLOCK;
 }
 
 }  // namespace beast

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

@@ -1370,7 +1370,7 @@ private:
             buck_.resize(size() + additional, cont_);
         XRPL_ASSERT(
             loadFactor() <= maxLoadFactor(),
-            "beast::detail::AgedUnorderedContainer::maybeRehash : maximum "
+            "beast::detail::AgedUnorderedContainer::maybe_rehash : maximum "
             "load factor");
     }
 

include/xrpl/beast/core/CurrentThreadName.h

@@ -21,7 +21,7 @@ setCurrentThreadName(std::string_view newThreadName);
 
 // On Linux, thread names are limited to 16 bytes including the null terminator.
 // Maximum number of characters is therefore 15.
-constexpr std::size_t kMaxThreadNameLength = 15;
+constexpr std::size_t kMAX_THREAD_NAME_LENGTH = 15;
 
 /** Sets the name of the caller thread with compile-time size checking.
     @tparam N The size of the string literal including null terminator
@@ -34,7 +34,7 @@ template <std::size_t N>
 void
 setCurrentThreadName(char const (&newThreadName)[N])
 {
-    static_assert(N <= kMaxThreadNameLength + 1, "Thread name cannot exceed 15 characters");
+    static_assert(N <= kMAX_THREAD_NAME_LENGTH + 1, "Thread name cannot exceed 15 characters");
 
     setCurrentThreadName(std::string_view(newThreadName, N - 1));
 }

include/xrpl/beast/hash/hash_append.h

@@ -53,7 +53,7 @@ inline void
 maybeReverseBytes(T& t, Hasher&)
 {
     maybeReverseBytes(
-        t, std::integral_constant<bool, Hasher::kEndian != boost::endian::order::native>{});
+        t, std::integral_constant<bool, Hasher::kENDIAN != boost::endian::order::native>{});
 }
 
 }  // namespace detail
@@ -154,7 +154,7 @@ struct IsContiguouslyHashable
     : public std::integral_constant<
           bool,
           IsUniquelyRepresented<T>::value &&
-              (sizeof(T) == 1 || HashAlgorithm::kEndian == boost::endian::order::native)>
+              (sizeof(T) == 1 || HashAlgorithm::kENDIAN == boost::endian::order::native)>
 {
     explicit IsContiguouslyHashable() = default;
 };

include/xrpl/beast/hash/xxhasher.h

@@ -21,9 +21,9 @@ private:
     static_assert(sizeof(std::size_t) == 8, "requires 64-bit std::size_t");
     // Have an internal buffer to avoid the streaming API
     // A 64-byte buffer should to be big enough for us
-    static constexpr std::size_t kInternalBufferSize = 64;
+    static constexpr std::size_t kINTERNAL_BUFFER_SIZE = 64;
 
-    alignas(64) std::array<std::uint8_t, kInternalBufferSize> buffer_{};
+    alignas(64) std::array<std::uint8_t, kINTERNAL_BUFFER_SIZE> buffer_{};
     std::span<std::uint8_t> readBuffer_;
     std::span<std::uint8_t> writeBuffer_;
 
@@ -102,7 +102,7 @@ private:
     }
 
 public:
-    static constexpr auto kEndian = boost::endian::order::native;
+    static constexpr auto const kENDIAN = boost::endian::order::native;
 
     Xxhasher(Xxhasher const&) = delete;
     Xxhasher&

include/xrpl/beast/unit_test/reporter.h

@@ -62,7 +62,9 @@ private:
     {
         using run_time = std::pair<std::string, typename clock_type::duration>;
 
-        static constexpr auto kMaxTop = 10;
+        // Need to be named before converting
+        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
+        enum { MaxTop = 10 };
 
         std::size_t suites = 0;
         std::size_t cases = 0;
@@ -77,8 +79,8 @@ private:
 
     std::ostream& os_;
     Results results_;
-    SuiteResults suiteResults_;
-    CaseResults caseResults_;
+    SuiteResults suite_results_;
+    CaseResults case_results_;
 
 public:
     Reporter(Reporter const&) = delete;
@@ -146,11 +148,11 @@ Reporter<Unused>::Results::add(SuiteResults const& r)
             });
         if (iter != top.end())
         {
-            if (top.size() == kMaxTop)
+            if (top.size() == MaxTop)
                 top.resize(top.size() - 1);
             top.emplace(iter, r.name, elapsed);
         }
-        else if (top.size() < kMaxTop)
+        else if (top.size() < MaxTop)
         {
             top.emplace_back(r.name, elapsed);
         }
@@ -196,22 +198,22 @@ template <class Unused>
 void
 Reporter<Unused>::onSuiteBegin(SuiteInfo const& info)
 {
-    suiteResults_ = SuiteResults{info.fullName()};
+    suite_results_ = SuiteResults{info.fullName()};
 }
 
 template <class Unused>
 void
 Reporter<Unused>::onSuiteEnd()
 {
-    results_.add(suiteResults_);
+    results_.add(suite_results_);
 }
 
 template <class Unused>
 void
 Reporter<Unused>::onCaseBegin(std::string const& name)
 {
-    caseResults_ = CaseResults(name);
-    os_ << suiteResults_.name << (caseResults_.name.empty() ? "" : (" " + caseResults_.name))
+    case_results_ = CaseResults(name);
+    os_ << suite_results_.name << (case_results_.name.empty() ? "" : (" " + case_results_.name))
         << std::endl;
 }
 
@@ -219,23 +221,23 @@ template <class Unused>
 void
 Reporter<Unused>::onCaseEnd()
 {
-    suiteResults_.add(caseResults_);
+    suite_results_.add(case_results_);
 }
 
 template <class Unused>
 void
 Reporter<Unused>::onPass()
 {
-    ++caseResults_.total;
+    ++case_results_.total;
 }
 
 template <class Unused>
 void
 Reporter<Unused>::onFail(std::string const& reason)
 {
-    ++caseResults_.failed;
-    ++caseResults_.total;
-    os_ << "#" << caseResults_.total << " failed" << (reason.empty() ? "" : ": ") << reason
+    ++case_results_.failed;
+    ++case_results_.total;
+    os_ << "#" << case_results_.total << " failed" << (reason.empty() ? "" : ": ") << reason
         << std::endl;
 }
 

include/xrpl/beast/unit_test/suite.h

@@ -299,8 +299,8 @@ private:
     static Suite**
     pThisSuite()
     {
-        static Suite* kPTs = nullptr;  // NOLINT TODO
-        return &kPTs;
+        static Suite* kP_TS = nullptr;  // NOLINT TODO
+        return &kP_TS;
     }
 
     /** Runs the suite. */

include/xrpl/beast/utility/Journal.h

@@ -2,25 +2,29 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <cstdint>
 #include <sstream>
 
 namespace beast {
 
+/** A namespace for easy access to logging severity values. */
+namespace severities {
 /** Severity level / threshold of a Journal message. */
-enum class Severity : std::uint8_t {
-    All = 0,
+// Hundreds of usages via logging macros
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
+enum Severity {
+    KAll = 0,
 
-    Trace = All,
-    Debug = 1,
-    Info = 2,
-    Warning = 3,
-    Error = 4,
-    Fatal = 5,
+    KTrace = KAll,
+    KDebug = 1,
+    KInfo = 2,
+    KWarning = 3,
+    KError = 4,
+    KFatal = 5,
 
-    Disabled = 6,
-    None = Disabled
+    KDisabled = 6,
+    KNone = KDisabled
 };
+}  // namespace severities
 
 /** A generic endpoint for log messages.
 
@@ -40,6 +44,9 @@ public:
     class Sink;
 
 private:
+    // Severity level / threshold of a Journal message.
+    using Severity = severities::Severity;
+
     // Invariant: sink_ always points to a valid Sink
     Sink* sink_;
 
@@ -176,7 +183,7 @@ public:
     {
     public:
         /** Create a stream which produces no output. */
-        explicit Stream() : sink_(getNullSink()), level_(Severity::Disabled)
+        explicit Stream() : sink_(getNullSink()), level_(severities::KDisabled)
         {
         }
 
@@ -187,7 +194,7 @@ public:
         Stream(Sink& sink, Severity level) : sink_(sink), level_(level)
         {
             XRPL_ASSERT(
-                level_ < Severity::Disabled, "beast::Journal::Stream::Stream : maximum level");
+                level_ < severities::KDisabled, "beast::Journal::Stream::Stream : maximum level");
         }
 
         /** Construct or copy another Stream. */
@@ -290,37 +297,37 @@ public:
     [[nodiscard]] Stream
     trace() const
     {
-        return {*sink_, Severity::Trace};
+        return {*sink_, severities::KTrace};
     }
 
     [[nodiscard]] Stream
     debug() const
     {
-        return {*sink_, Severity::Debug};
+        return {*sink_, severities::KDebug};
     }
 
     [[nodiscard]] Stream
     info() const
     {
-        return {*sink_, Severity::Info};
+        return {*sink_, severities::KInfo};
     }
 
     [[nodiscard]] Stream
     warn() const
     {
-        return {*sink_, Severity::Warning};
+        return {*sink_, severities::KWarning};
     }
 
     [[nodiscard]] Stream
     error() const
     {
-        return {*sink_, Severity::Error};
+        return {*sink_, severities::KError};
     }
 
     [[nodiscard]] Stream
     fatal() const
     {
-        return {*sink_, Severity::Fatal};
+        return {*sink_, severities::KFatal};
     }
     /** @} */
 };

include/xrpl/beast/utility/WrappedSink.h

@@ -36,7 +36,7 @@ public:
     }
 
     [[nodiscard]] bool
-    active(beast::Severity level) const override
+    active(beast::severities::Severity level) const override
     {
         return sink_.active(level);
     }
@@ -53,27 +53,27 @@ public:
         sink_.console(output);
     }
 
-    [[nodiscard]] beast::Severity
+    [[nodiscard]] beast::severities::Severity
     threshold() const override
     {
         return sink_.threshold();
     }
 
     void
-    threshold(beast::Severity thresh) override
+    threshold(beast::severities::Severity thresh) override
     {
         sink_.threshold(thresh);
     }
 
     void
-    write(beast::Severity level, std::string const& text) override
+    write(beast::severities::Severity level, std::string const& text) override
     {
         using beast::Journal;
         sink_.write(level, prefix_ + text);
     }
 
     void
-    writeAlways(Severity level, std::string const& text) override
+    writeAlways(severities::Severity level, std::string const& text) override
     {
         using beast::Journal;
         sink_.writeAlways(level, prefix_ + text);

include/xrpl/beast/utility/Zero.h

@@ -27,7 +27,7 @@ struct Zero
 };
 
 namespace {
-constexpr Zero kZero{};
+constexpr Zero kZERO{};
 }  // namespace
 
 /** Default implementation of signum calls the method on the class. */
@@ -102,42 +102,42 @@ template <typename T>
 bool
 operator==(Zero, T const& t)
 {
-    return t == kZero;
+    return t == kZERO;
 }
 
 template <typename T>
 bool
 operator!=(Zero, T const& t)
 {
-    return t != kZero;
+    return t != kZERO;
 }
 
 template <typename T>
 bool
 operator<(Zero, T const& t)
 {
-    return t > kZero;
+    return t > kZERO;
 }
 
 template <typename T>
 bool
 operator>(Zero, T const& t)
 {
-    return t < kZero;
+    return t < kZERO;
 }
 
 template <typename T>
 bool
 operator>=(Zero, T const& t)
 {
-    return t <= kZero;
+    return t <= kZERO;
 }
 
 template <typename T>
 bool
 operator<=(Zero, T const& t)
 {
-    return t >= kZero;
+    return t >= kZERO;
 }
 
 }  // namespace beast

include/xrpl/beast/utility/rngfill.h

@@ -14,23 +14,23 @@ void
 rngfill(void* const buffer, std::size_t const bytes, Generator& g)
 {
     using result_type = typename Generator::result_type;
-    constexpr std::size_t kResultSize = sizeof(result_type);
+    constexpr std::size_t kRESULT_SIZE = sizeof(result_type);
 
     std::uint8_t* const bufferStart = static_cast<std::uint8_t*>(buffer);
-    std::size_t const completeIterations = bytes / kResultSize;
-    std::size_t const bytesRemaining = bytes % kResultSize;
+    std::size_t const completeIterations = bytes / kRESULT_SIZE;
+    std::size_t const bytesRemaining = bytes % kRESULT_SIZE;
 
     for (std::size_t count = 0; count < completeIterations; ++count)
     {
         result_type const v = g();
-        std::size_t const offset = count * kResultSize;
-        std::memcpy(bufferStart + offset, &v, kResultSize);
+        std::size_t const offset = count * kRESULT_SIZE;
+        std::memcpy(bufferStart + offset, &v, kRESULT_SIZE);
     }
 
     if (bytesRemaining > 0)
     {
         result_type const v = g();
-        std::size_t const offset = completeIterations * kResultSize;
+        std::size_t const offset = completeIterations * kRESULT_SIZE;
         std::memcpy(bufferStart + offset, &v, bytesRemaining);
     }
 }

include/xrpl/beast/xor_shift_engine.h

@@ -26,14 +26,12 @@ public:
     result_type
     operator()();
 
-    static constexpr result_type
-    min()
+    static result_type constexpr min()
     {
         return std::numeric_limits<result_type>::min();
     }
 
-    static constexpr result_type
-    max()
+    static result_type constexpr max()
     {
         return std::numeric_limits<result_type>::max();
     }

include/xrpl/conditions/Condition.h

@@ -27,7 +27,7 @@ public:
               that were previously considered valid to no longer
               be allowed.
     */
-    static constexpr std::size_t kMaxSerializedCondition = 128;
+    static constexpr std::size_t kMAX_SERIALIZED_CONDITION = 128;
 
     /** Load a condition from its binary form
 

include/xrpl/conditions/Fulfillment.h

@@ -16,7 +16,7 @@ public:
               that were previously considered valid to no longer
               be allowed.
     */
-    static constexpr std::size_t kMaxSerializedFulfillment = 256;
+    static constexpr std::size_t kMAX_SERIALIZED_FULFILLMENT = 256;
 
     /** Load a fulfillment from its binary form
 

include/xrpl/conditions/detail/PreimageSha256.h

@@ -23,7 +23,7 @@ public:
         While future versions of this code will never lower
         this limit, they may opt to raise it.
     */
-    static constexpr std::size_t kMaxPreimageLength = 128;
+    static constexpr std::size_t kMAX_PREIMAGE_LENGTH = 128;
 
     /** Parse the payload for a PreimageSha256 condition
 
@@ -65,7 +65,7 @@ public:
             return {};
         }
 
-        if (s.size() > kMaxPreimageLength)
+        if (s.size() > kMAX_PREIMAGE_LENGTH)
         {
             ec = Error::PreimageTooLong;
             return {};