test(testnet): assert zero entropy in degraded ledgers

Regenerate sfcodes.h to include the new sfSidecarType field
(UINT8, code 20).  Also apply clang-format to ConsensusExtensions.cpp.

.clang-format

@@ -44,7 +44,6 @@ DerivePointerAlignment: false
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
 ForEachMacros:   [ Q_FOREACH,  BOOST_FOREACH ]
-IncludeBlocks:   Regroup
 IncludeCategories:
   - Regex:           '^<(test)/'
     Priority:        0
@@ -54,12 +53,8 @@ IncludeCategories:
     Priority:        2
   - Regex:           '^<(boost)/'
     Priority:        3
-  - Regex:           '^.*/'
-    Priority:        4
-  - Regex:           '^.*\.h'
-    Priority:        5
   - Regex:           '.*'
-    Priority:        6
+    Priority:        4
 IncludeIsMainRegex: '$'
 IndentCaseLabels: true
 IndentFunctionDeclarationAfterType: false
@@ -94,4 +89,3 @@ SpacesInSquareBrackets: false
 Standard:        Cpp11
 TabWidth:        8
 UseTab:          Never
-QualifierAlignment: Right

.github/workflows/clang-format.yml

@@ -8,15 +8,6 @@ jobs:
     env:
       CLANG_VERSION: 18
     steps:
-      # For jobs running in containers, $GITHUB_WORKSPACE and ${{ github.workspace }} might not be the
-      # same directory. The actions/checkout step is *supposed* to checkout into $GITHUB_WORKSPACE and
-      # then add it to safe.directory (see instructions at https://github.com/actions/checkout)
-      # but that's apparently not happening for some container images. We can't be sure what is actually
-      # happening, so let's pre-emptively add both directories to safe.directory. There's a
-      # Github issue opened in 2022 and not resolved in 2025 https://github.com/actions/runner/issues/2058 ¯\_(ツ)_/¯
-    - run: |
-        git config --global --add safe.directory $GITHUB_WORKSPACE
-        git config --global --add safe.directory ${{ github.workspace }}
     - uses: actions/checkout@v4
     - name: Install clang-format
       run: |
@@ -29,7 +20,7 @@ jobs:
         sudo apt-get update
         sudo apt-get install clang-format-${CLANG_VERSION}
     - name: Format first-party sources
-      run: find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -not -path "src/magic/magic_enum.h" -exec clang-format-${CLANG_VERSION} -i {} +
+      run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -not -path "src/magic/magic_enum.h" -exec clang-format-${CLANG_VERSION} -i {} +
     - name: Check for differences
       id: assert
       run: |

.github/workflows/levelization.yml

@@ -11,6 +11,11 @@ jobs:
     - uses: actions/checkout@v3
     - name: Check levelization
       run: Builds/levelization/levelization.sh
+    - name: Verify Python Generator Matches Canonical Script
+      run: |
+        python3 Builds/levelization/levelization.py \
+          --results-dir /tmp/levelization-py-results \
+          --compare-to Builds/levelization/results
     - name: Check for differences
       id: assert
       run: |

.github/workflows/xahau-ga-macos.yml

@@ -122,6 +122,4 @@ jobs:
 
       - name: Test
         run: |
-          cd ${{ env.build_dir }}
-          ./rippled --unittest --unittest-jobs $(nproc)
-          ctest -j $(nproc) --output-on-failure
+          ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)

.github/workflows/xahau-ga-nix.yml

@@ -370,9 +370,7 @@ jobs:
         run: |
           # Ensure the binary exists before trying to run
           if [ -f "${{ env.build_dir }}/rippled" ]; then
-            cd ${{ env.build_dir }}
-            ./rippled --unittest --unittest-jobs $(nproc)
-            ctest -j $(nproc) --output-on-failure
+            ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)
           else
              echo "Error: rippled executable not found in ${{ env.build_dir }}"
              exit 1

.gitignore

@@ -124,5 +124,8 @@ bld.rippled/
 generated
 .vscode
 
+# AI docs (local working documents)
+.ai-docs/
+
 # Suggested in-tree build directory
 /.build/

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 # .pre-commit-config.yaml
 repos:
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v18.1.8
+  rev: v18.1.3
   hooks:
   - id: clang-format

.testnet/.gitignore

@@ -0,0 +1,4 @@
+output/
+__pycache__/
+scenarios/odd-cases/
+scenarios/suite-experiments.yml

.testnet/scenarios/entropy/consensus_entropy_crash.py

@@ -0,0 +1,27 @@
+"""Scenario: ConsensusEntropy amendment crashes non-supporting node.
+
+Votes ConsensusEntropy accept on all nodes except n4, then waits for n4
+to crash as the amendment activates without its support.
+
+    x-testnet run --scenario-script consensus_entropy_crash.py
+"""
+
+
+async def scenario(ctx, log):
+    await ctx.wait_for_ledger_close()
+    ctx.feature("ConsensusEntropy", vetoed=False, exclude_nodes=[4])
+
+    log("Waiting for ConsensusEntropy to be voted for...")
+    await ctx.wait_for_feature(
+        "ConsensusEntropy",
+        check=lambda s: not s.get("vetoed"),
+        exclude_nodes=[4],
+        timeout=60,
+    )
+
+    log("Waiting for n4 to crash...")
+    op = await ctx.wait_for_nodes_down(nodes=[4], timeout=600)
+
+    ctx.assert_log("unsupported amendments activated", since=op.started, nodes=[4])
+    ctx.assert_exit_status(0, nodes=[4])
+    log("PASS: n4 shut down due to unsupported amendment")

.testnet/scenarios/entropy/entropy_with_transactions.py

@@ -0,0 +1,52 @@
+""":descr: entropy stays valid under transaction load"""
+
+from __future__ import annotations
+
+from helpers import require_entropy, get_entropy_tx, assert_valid_entropy
+
+variants = [
+    {"label": "light", "min_txns": 5, "max_txns": 10},
+    {"label": "heavy", "min_txns": 50, "max_txns": 60},
+    {"label": "super_heavy", "min_txns": 90, "max_txns": 120},
+]
+
+
+async def scenario(ctx, log, *, min_txns=5, max_txns=10, **_):
+    await require_entropy(ctx, log)
+
+    gen = ctx.txn_generator(min_txns=min_txns, max_txns=max_txns)
+    await gen.start()
+    await gen.wait_until_ready()
+    log(f"Transaction generator ready ({min_txns}-{max_txns} txns/ledger)")
+
+    # Wait for pipeline warmup + a few txn-bearing ledgers.
+    await ctx.wait_for_ledgers(3, node_id=0, timeout=60)
+
+    start_seq = ctx.validated_ledger_index(0)
+    await ctx.wait_for_ledgers(10, node_id=0, timeout=120)
+    end_seq = ctx.validated_ledger_index(0)
+    log(f"Inspecting ledgers {start_seq + 1} → {end_seq}")
+
+    digests = set()
+    total_user_txns = 0
+
+    for seq in range(start_seq + 1, end_seq + 1):
+        ce, user_txns = get_entropy_tx(ctx, seq)
+        digest, count = assert_valid_entropy(ce, seq, seen_digests=digests)
+        total_user_txns += len(user_txns)
+        log(
+            f"  Ledger {seq}: EntropyCount={count} "
+            f"user_txns={len(user_txns)} Digest={digest[:16]}..."
+        )
+
+    await gen.stop()
+
+    log(
+        f"Verified {end_seq - start_seq} ledgers: {total_user_txns} user txns, "
+        f"all entropy valid and unique"
+    )
+
+    if total_user_txns == 0:
+        raise AssertionError("No user transactions were included in any ledger")
+
+    log("PASS")

.testnet/scenarios/entropy/quorum_degradation_smoke.py

@@ -0,0 +1,117 @@
+""":descr: 4/5 liveness, 3/5 zero-entropy fallback, recovery"""
+
+from __future__ import annotations
+
+from helpers import require_entropy, get_entropy_tx, entropy_fields
+
+
+async def scenario(ctx, log):
+    await require_entropy(ctx, log)
+
+    # Baseline: wait 1 ledger to confirm network is healthy.
+    await ctx.wait_for_ledgers(1, node_id=0, timeout=30)
+
+    # --- 4/5 liveness ---
+    ctx.stop_node(4)
+    await ctx.wait_for_nodes_down(nodes=[4], timeout=30)
+    await ctx.wait_for_ledgers(1, node_id=0, timeout=30)
+    log("4/5: liveness OK")
+
+    # Snapshot validated seq before dropping to 3/5.
+    val_before = ctx.validated_ledger_index(0)
+
+    # --- 3/5 degraded window ---
+    ctx.stop_node(3)
+    await ctx.wait_for_nodes_down(nodes=[3], timeout=30)
+
+    # 10s ≈ 3 rounds at 3s cadence.
+    await ctx.sleep(10)
+
+    val_after = ctx.validated_ledger_index(0)
+    log(f"3/5: validated ledger {val_before} → {val_after}")
+
+    # Accepted/built ledgers may still later appear as validated once the full
+    # network rejoins. For ConsensusEntropy the key invariant is that every
+    # ledger created during this sub-quorum window carries ZERO entropy.
+    degraded_zero = 0
+    degraded_end = val_after or val_before
+    if val_before and degraded_end and degraded_end > val_before:
+        for seq in range(val_before + 1, degraded_end + 1):
+            ce, _ = get_entropy_tx(ctx, seq)
+            digest, entropy_count, is_zero = entropy_fields(ce)
+
+            if not is_zero:
+                raise AssertionError(
+                    f"Ledger {seq}: expected ZERO entropy during 3/5 window, "
+                    f"got Digest={digest[:16]}... EntropyCount={entropy_count}"
+                )
+
+            degraded_zero += 1
+            log(f"  Degraded ledger {seq}: EntropyCount={entropy_count} ZERO")
+
+    log(f"3/5 entropy summary: {degraded_zero} zero")
+
+    # Log checks tied to actual transition mechanics:
+    # - seq=1 proposals are emitted once commit-set phase is entered
+    # - ConvergingCommit transition is the gateway out of seq=0-only behavior
+    # - establish gate blocked indicates tx-consensus/pause prevented accept
+    ctx.log_level("LedgerConsensus", "trace")
+    op = await ctx.sleep(6, name="stall_window")
+
+    ctx.assert_not_log(
+        r"RNG: transitioned to ConvergingCommit", within=op.window, nodes=[0, 1, 2]
+    )
+    ctx.assert_not_log(r"RNG: propose seq=1", within=op.window, nodes=[0, 1, 2])
+
+    gate_blocked = ctx.search_logs(
+        r"STALLDIAG: establish gate blocked reason=(pause|no-tx-consensus)",
+        within=op.window,
+        nodes=[0, 1, 2],
+    )
+    log(f"3/5: establish gate-blocked logs in 6s: {gate_blocked.count}")
+
+    skips = ctx.search_logs(r"RNG: bootstrap skip", within=op.window, nodes=[0, 1, 2])
+    log(f"3/5: RNG bootstrap skips in 6s: {skips.count}")
+
+    # --- Recovery: restart nodes, verify ledger advancement ---
+    ctx.start_node(3)
+    ctx.start_node(4)
+    await ctx.wait_for_ledgers(1, node_id=0, timeout=120)
+
+    val_recovered = ctx.validated_ledger_index(0)
+    pre_recovery = max(v for v in [val_before, val_after] if v is not None)
+    log(f"Recovered: validated seq {pre_recovery} → {val_recovered}")
+
+    if not val_recovered or val_recovered <= pre_recovery:
+        raise AssertionError(
+            f"Validated ledger did not advance after recovery "
+            f"({pre_recovery} → {val_recovered})"
+        )
+
+    # Inspect post-recovery ledgers separately from the degraded window above.
+    # Once the network is back at quorum, non-zero entropy is valid again but
+    # must still be quorum-met.
+    zero_count = 0
+    nonzero_count = 0
+    for seq in range(pre_recovery + 1, val_recovered + 1):
+        ce, _ = get_entropy_tx(ctx, seq)
+        digest, entropy_count, is_zero = entropy_fields(ce)
+
+        if is_zero:
+            zero_count += 1
+        else:
+            nonzero_count += 1
+            if entropy_count < 4:
+                raise AssertionError(
+                    f"Ledger {seq}: non-zero entropy with sub-quorum "
+                    f"EntropyCount={entropy_count} (need >= 4)"
+                )
+
+        log(
+            f"  Ledger {seq}: EntropyCount={entropy_count} "
+            f"{'ZERO' if is_zero else 'REAL'}"
+        )
+
+    log(f"Entropy summary: {zero_count} zero, {nonzero_count} non-zero")
+
+    log("PASS")

.testnet/scenarios/entropy/quorum_recovery_smoke.py

@@ -0,0 +1,46 @@
+""":descr: drop 2 nodes (3/5 stall), restart both, verify recovery"""
+
+from __future__ import annotations
+
+
+async def scenario(ctx, log):
+    await ctx.wait_for_ledger_close(timeout=120)
+
+    feature = ctx.feature_check("ConsensusEntropy", node_id=0)
+    if not feature or not feature.get("enabled", False):
+        raise AssertionError(f"ConsensusEntropy not enabled: {feature}")
+
+    await ctx.wait_for_ledgers(1, node_id=0, timeout=60)
+    log("Baseline OK")
+
+    # Drop 2 nodes → validation stall.
+    ctx.stop_node(3)
+    ctx.stop_node(4)
+    await ctx.wait_for_nodes_down(nodes=[3, 4], timeout=30)
+
+    info = ctx.rpc.server_info(node_id=0)
+    val_before = info.get("info", {}).get("validated_ledger", {}).get("seq", 0)
+    log(f"Stalled at validated seq {val_before}")
+
+    # Let it sit for a few rounds in degraded state.
+    await ctx.sleep(6)
+
+    # Bring both nodes back.
+    ctx.start_node(3)
+    ctx.start_node(4)
+    log("Restarted n3 and n4, waiting for recovery...")
+
+    # Recovery: wait for ANY validated ledger advance on n0.
+    await ctx.wait_for_ledger_close(node_id=0, timeout=60)
+
+    info = ctx.rpc.server_info(node_id=0)
+    val_after = info.get("info", {}).get("validated_ledger", {}).get("seq", 0)
+    log(f"Recovered: validated seq {val_before} → {val_after}")
+
+    if val_after <= val_before:
+        raise AssertionError(
+            f"Validated ledger did not advance after recovery "
+            f"({val_before} → {val_after})"
+        )
+
+    log("PASS")

.testnet/scenarios/entropy/steady_state_entropy.py

@@ -0,0 +1,27 @@
+""":descr: all 5 nodes healthy, every ledger has valid unique quorum-met entropy"""
+
+from __future__ import annotations
+
+from helpers import require_entropy, get_entropy_tx, assert_valid_entropy
+
+
+async def scenario(ctx, log):
+    await require_entropy(ctx, log)
+
+    # Wait for RNG pipeline to warm up past bootstrap skip.
+    await ctx.wait_for_ledgers(3, node_id=0, timeout=60)
+    log("Pipeline warmed up")
+
+    start_seq = ctx.validated_ledger_index(0)
+    await ctx.wait_for_ledgers(10, node_id=0, timeout=120)
+    end_seq = ctx.validated_ledger_index(0)
+    log(f"Inspecting ledgers {start_seq + 1} → {end_seq}")
+
+    digests = set()
+    for seq in range(start_seq + 1, end_seq + 1):
+        ce, _ = get_entropy_tx(ctx, seq)
+        digest, count = assert_valid_entropy(ce, seq, seen_digests=digests)
+        log(f"  Ledger {seq}: EntropyCount={count} Digest={digest[:16]}...")
+
+    log(f"Verified {end_seq - start_seq} ledgers: all quorum entropy, all unique")
+    log("PASS")

.testnet/scenarios/export-suite.yml

@@ -0,0 +1,71 @@
+defaults:
+  network:
+    node_count: 5
+    launcher: tmux
+    slave_delay: 0.2
+    features:
+      - ConsensusEntropy
+      - Export
+    track_features:
+      - ConsensusEntropy
+      - Export
+    log_levels:
+      TxQ: info
+      Protocol: debug
+      Peer: debug
+      LedgerConsensus: debug
+      NetworkOPs: info
+    env:
+      XAHAU_RESOURCE_PER_PORT: "1"
+      XAHAU_RNG_POLL_MS: "333"
+
+tests:
+  # --- CE + Export (80% quorum, SHAMap convergence) ---
+  - name: steady_state_export_ce
+    script: .testnet/scenarios/export/steady_state_export.py
+
+  - name: retriable_export_ce
+    script: .testnet/scenarios/export/retriable_export.py
+
+  - name: export_degradation_ce
+    script: .testnet/scenarios/export/export_degradation.py
+    network:
+      node_env:
+        3:
+          XAHAUD_NO_EXPORT_SIG: "1"
+        4:
+          XAHAUD_NO_EXPORT_SIG: "1"
+
+  # CE + Export: 1 node suppressed, 4/5 = 80% quorum, should succeed
+  - name: export_ce_one_node_down
+    script: .testnet/scenarios/export/export_unanimity.py
+    params:
+      expect_success: true
+    network:
+      node_env:
+        4:
+          XAHAUD_NO_EXPORT_SIG: "1"
+
+  # --- Export only, no CE (100% quorum, unanimity) ---
+  - name: export_unanimity_all_up
+    script: .testnet/scenarios/export/export_unanimity.py
+    params:
+      expect_success: true
+    network:
+      features:
+        - Export
+      track_features:
+        - Export
+
+  - name: export_unanimity_node_down
+    script: .testnet/scenarios/export/export_unanimity.py
+    params:
+      expect_success: false
+    network:
+      features:
+        - Export
+      track_features:
+        - Export
+      node_env:
+        4:
+          XAHAUD_NO_EXPORT_SIG: "1"

.testnet/scenarios/export/export_degradation.py

@@ -0,0 +1,102 @@
+""":descr: Submit ttEXPORT with 2 nodes suppressing export sigs, verify it
+retries via terRETRY_EXPORT until LLS expiry (not enough sigs for quorum).
+
+Nodes 3 and 4 have XAHAUD_NO_EXPORT_SIG=1, so only 3/5 nodes provide
+export signatures. With 80% quorum = ceil(5*0.8) = 4 required, the
+export cannot reach quorum and should expire via tecEXPORT_EXPIRED.
+
+Flow:
+  1. Fund alice and bob
+  2. alice submits ttEXPORT with tight LLS
+  3. Export retries (only 3/5 sigs available, need 4)
+  4. Verify export expires with tecEXPORT_EXPIRED
+  5. Verify subsequent payment still works (sequence not permanently blocked)
+"""
+
+from __future__ import annotations
+
+from export_helpers import require_export, assert_shadow_ticket
+
+
+async def scenario(ctx, log):
+    await require_export(ctx, log)
+
+    # --- Setup ---
+    await ctx.fund_accounts({"alice": 10000, "bob": 1000})
+    log("Accounts funded")
+
+    alice = ctx.account("alice")
+    bob = ctx.account("bob")
+    current_seq = ctx.validated_ledger_index(0)
+
+    log(f"Current ledger: {current_seq}")
+    log("Nodes 3,4 have XAHAUD_NO_EXPORT_SIG=1 (3/5 sigs, need 4)")
+
+    # --- Submit ttEXPORT (should retry then expire -- only 3/5 sigs) ---
+    result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Export",
+            "LastLedgerSequence": current_seq + 8,
+            "Fee": "1000000",
+            "ExportedTxn": {
+                "TransactionType": "Payment",
+                "Account": alice.address,
+                "Destination": bob.address,
+                "Amount": "1000000",
+                "Fee": "10",
+                "Sequence": 0,
+                "TicketSequence": 1,
+                "FirstLedgerSequence": current_seq + 1,
+                "LastLedgerSequence": current_seq + 6,
+                "Flags": 2147483648,
+                "SigningPubKey": "",
+            },
+        },
+        alice.wallet,
+        timeout=60,
+    )
+
+    final_seq = ctx.validated_ledger_index(0)
+    engine_result = result.get("engine_result", "")
+    log(f"Export completed at ledger {final_seq}, result: {engine_result}")
+
+    # With only 3/5 sigs and 80% quorum (4 required), export MUST fail
+    if engine_result == "tesSUCCESS":
+        raise AssertionError(
+            "Export should NOT have succeeded with only 3/5 sigs "
+            "(need 4 for 80% quorum) -- check XAHAUD_NO_EXPORT_SIG config"
+        )
+
+    # Should be tecEXPORT_EXPIRED (LLS reached without quorum)
+    if engine_result != "tecEXPORT_EXPIRED":
+        log(f"WARNING: expected tecEXPORT_EXPIRED, got {engine_result}")
+
+    log(f"Export failed as expected ({engine_result})")
+
+    # No shadow ticket should exist (export never reached quorum)
+    assert_shadow_ticket(ctx, alice.address, log, expect_exists=False)
+
+    # --- Verify subsequent payment works regardless ---
+    log("Submitting payment from alice to bob...")
+    pay_result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Payment",
+            "Destination": bob.address,
+            "Amount": "1000000",
+            "Fee": "12",
+        },
+        alice.wallet,
+        timeout=30,
+    )
+
+    pay_engine = pay_result.get("engine_result", "")
+    log(f"Payment result: {pay_engine}")
+
+    if pay_engine != "tesSUCCESS":
+        raise AssertionError(
+            f"Payment failed after expired export: {pay_engine} "
+            f"-- sequence may be blocked"
+        )
+
+    log("Payment succeeded -- account not permanently blocked")
+    log("PASS")

.testnet/scenarios/export/export_helpers.py

@@ -0,0 +1,144 @@
+"""Shared helpers for Export scenario tests."""
+
+from __future__ import annotations
+
+
+async def require_export(ctx, log):
+    """Wait for first ledger and assert Export amendment is enabled."""
+    await ctx.wait_for_ledger_close(timeout=120)
+    feature = ctx.feature_check("Export", node_id=0)
+    if not feature or not feature.get("enabled", False):
+        raise AssertionError(f"Export not enabled: {feature}")
+    log("Export amendment enabled")
+
+
+def find_export_txns(ctx, seq):
+    """Find Export transactions in a ledger.
+
+    Returns list of Export transaction dicts.
+    """
+    result = ctx.ledger(seq, transactions=True)
+    if not result:
+        return []
+
+    txns = result.get("ledger", {}).get("transactions", [])
+    return [tx for tx in txns if tx.get("TransactionType") == "Export"]
+
+
+def dst_param(address):
+    """Encode an address as a HookParameter entry for the DST param."""
+    from xrpl.core.addresscodec import decode_classic_address
+
+    dst_hex = decode_classic_address(address).hex().upper()
+    return {
+        "HookParameter": {
+            "HookParameterName": "445354",  # "DST"
+            "HookParameterValue": dst_hex,
+        }
+    }
+
+
+def assert_hook_accepted(meta, log, *, expected_emits=1):
+    """Assert hook executed with ACCEPT and the expected emit count.
+
+    Checks sfHookExecutions in transaction metadata.
+    Returns the hook execution entry for further inspection.
+    """
+    hook_execs = meta.get("HookExecutions", [])
+    if not hook_execs:
+        raise AssertionError("No HookExecutions in metadata")
+
+    exec_entry = hook_execs[0].get("HookExecution", {})
+    hook_result = exec_entry.get("HookResult", -1)
+    emit_count = exec_entry.get("HookEmitCount", -1)
+    return_code = exec_entry.get("HookReturnCode", "")
+
+    log(f"  HookResult={hook_result} EmitCount={emit_count} ReturnCode={return_code}")
+
+    # HookResult 3 = ExitType::ACCEPT
+    if hook_result != 3:
+        raise AssertionError(
+            f"Hook did not ACCEPT: HookResult={hook_result} "
+            f"ReturnCode={return_code}"
+        )
+
+    if emit_count != expected_emits:
+        raise AssertionError(
+            f"Expected {expected_emits} emits, got {emit_count}"
+        )
+
+    # ReturnCode 0 = success; non-zero = ASSERT line number in hook
+    if return_code and str(return_code) != "0":
+        raise AssertionError(
+            f"Hook returned error code {return_code} "
+            f"(likely ASSERT failure at that line)"
+        )
+
+    return exec_entry
+
+
+def assert_export_result(meta, log, *, require_signers=True):
+    """Assert ExportResult is present and well-formed in metadata.
+
+    Returns the ExportResult dict.
+    """
+    export_result = meta.get("ExportResult", {})
+    if not export_result:
+        raise AssertionError("ExportResult not found in metadata")
+
+    # Must have LedgerSequence and TransactionHash
+    if "LedgerSequence" not in export_result:
+        raise AssertionError("ExportResult missing LedgerSequence")
+    if "TransactionHash" not in export_result:
+        raise AssertionError("ExportResult missing TransactionHash")
+
+    # Must have the inner ExportedTxn object
+    inner = export_result.get("ExportedTxn", {})
+    if not inner:
+        raise AssertionError("ExportResult missing ExportedTxn (multisigned blob)")
+
+    log(f"  ExportResult: seq={export_result['LedgerSequence']} "
+        f"hash={export_result['TransactionHash'][:16]}...")
+
+    # Inner tx should have Account, Destination, TransactionType
+    if "Account" not in inner:
+        raise AssertionError("ExportedTxn missing Account")
+    if "TransactionType" not in inner:
+        raise AssertionError("ExportedTxn missing TransactionType")
+
+    # Should have empty SigningPubKey (multisigned)
+    if inner.get("SigningPubKey", "NOT_EMPTY") != "":
+        raise AssertionError(
+            f"ExportedTxn SigningPubKey should be empty, "
+            f"got '{inner.get('SigningPubKey')}'"
+        )
+
+    if require_signers:
+        signers = inner.get("Signers", [])
+        if not signers:
+            raise AssertionError("ExportedTxn has no Signers (multisig not applied)")
+        log(f"  Signers: {len(signers)} validator(s)")
+
+    return export_result
+
+
+def assert_shadow_ticket(ctx, account_address, log, *, expect_exists=True):
+    """Assert shadow ticket exists (or doesn't) for the account."""
+    obj_result = ctx.rpc.request(
+        0, "account_objects", {"account": account_address}
+    )
+    all_objects = (obj_result or {}).get("account_objects", [])
+    shadow_tickets = [
+        obj for obj in all_objects
+        if obj.get("LedgerEntryType") == "ShadowTicket"
+    ]
+    log(f"  Shadow tickets: {len(shadow_tickets)}")
+
+    if expect_exists and not shadow_tickets:
+        raise AssertionError("Expected shadow ticket but none found")
+    if not expect_exists and shadow_tickets:
+        raise AssertionError(
+            f"Expected no shadow tickets but found {len(shadow_tickets)}"
+        )
+
+    return shadow_tickets

.testnet/scenarios/export/export_unanimity.py

@@ -0,0 +1,111 @@
+""":descr: Test Export without CE (unanimity mode). When all 5 nodes are up,
+100% quorum is reachable and the export should succeed. When 1 node
+suppresses sigs (4/5), unanimity fails and the export should expire.
+
+Parameterized via `expect_success` kwarg from suite.yml.
+
+Flow:
+  1. Fund alice and bob
+  2. alice submits ttEXPORT
+  3. Verify result matches expectation (tesSUCCESS or tecEXPORT_EXPIRED)
+  4. Verify ExportResult + shadow ticket on success, absence on failure
+  5. Verify subsequent payment works regardless
+"""
+
+from __future__ import annotations
+
+from export_helpers import (
+    require_export,
+    assert_export_result,
+    assert_shadow_ticket,
+)
+
+
+async def scenario(ctx, log, expect_success=True):
+    await require_export(ctx, log)
+
+    # --- Setup ---
+    await ctx.fund_accounts({"alice": 10000, "bob": 1000})
+    log("Accounts funded")
+
+    alice = ctx.account("alice")
+    bob = ctx.account("bob")
+    current_seq = ctx.validated_ledger_index(0)
+
+    log(f"Current ledger: {current_seq}")
+    log(f"Expecting export {'success' if expect_success else 'failure (unanimity)'}")
+
+    # --- Submit ttEXPORT ---
+    result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Export",
+            "LastLedgerSequence": current_seq + 10,
+            "Fee": "1000000",
+            "ExportedTxn": {
+                "TransactionType": "Payment",
+                "Account": alice.address,
+                "Destination": bob.address,
+                "Amount": "1000000",
+                "Fee": "10",
+                "Sequence": 0,
+                "TicketSequence": 1,
+                "FirstLedgerSequence": current_seq + 1,
+                "LastLedgerSequence": current_seq + 8,
+                "Flags": 2147483648,
+                "SigningPubKey": "",
+            },
+        },
+        alice.wallet,
+        timeout=60,
+    )
+
+    final_seq = ctx.validated_ledger_index(0)
+    engine_result = result.get("engine_result", "")
+    meta = result.get("meta", {})
+
+    log(f"Export at ledger {final_seq}, result: {engine_result}")
+
+    if expect_success:
+        if engine_result != "tesSUCCESS":
+            raise AssertionError(
+                f"Expected tesSUCCESS, got {engine_result}"
+            )
+
+        # Assert ExportResult is well-formed with signers
+        assert_export_result(meta, log, require_signers=True)
+
+        # Assert shadow ticket was created
+        assert_shadow_ticket(ctx, alice.address, log, expect_exists=True)
+
+        log("Export succeeded as expected (all validators signed)")
+    else:
+        if engine_result == "tesSUCCESS":
+            raise AssertionError(
+                "Export should NOT have succeeded with sub-unanimity"
+            )
+        log(f"Export failed as expected ({engine_result})")
+
+        # No shadow ticket should exist
+        assert_shadow_ticket(ctx, alice.address, log, expect_exists=False)
+
+    # --- Verify subsequent payment works ---
+    log("Submitting payment from alice to bob...")
+    pay_result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Payment",
+            "Destination": bob.address,
+            "Amount": "1000000",
+            "Fee": "12",
+        },
+        alice.wallet,
+        timeout=30,
+    )
+
+    pay_engine = pay_result.get("engine_result", "")
+    log(f"Payment result: {pay_engine}")
+
+    if pay_engine != "tesSUCCESS":
+        raise AssertionError(f"Payment failed: {pay_engine}")
+
+    log("Payment succeeded -- account not blocked")
+    log("PASS")

.testnet/scenarios/export/retriable_export.py

@@ -0,0 +1,94 @@
+""":descr: Submit ttEXPORT directly (no hook), verify it succeeds with
+ExportResult in metadata. Then submit a payment from the same account
+to verify sequence handling doesn't block subsequent transactions.
+
+Flow:
+  1. Fund alice and bob
+  2. alice submits ttEXPORT with inner payment -> tesSUCCESS (provisional)
+  3. Validators attach sigs via proposals -> quorum -> ExportResult in metadata
+  4. alice submits a Payment to bob -> should succeed (sequence not blocked)
+"""
+
+from __future__ import annotations
+
+from export_helpers import require_export, assert_export_result, assert_shadow_ticket
+
+
+async def scenario(ctx, log):
+    await require_export(ctx, log)
+
+    # --- Setup ---
+    await ctx.fund_accounts({"alice": 10000, "bob": 1000})
+    log("Accounts funded")
+
+    alice = ctx.account("alice")
+    bob = ctx.account("bob")
+    current_seq = ctx.validated_ledger_index(0)
+
+    log(f"Current ledger: {current_seq}")
+
+    # --- 1. Submit ttEXPORT ---
+    result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Export",
+            "LastLedgerSequence": current_seq + 15,
+            "Fee": "1000000",
+            "ExportedTxn": {
+                "TransactionType": "Payment",
+                "Account": alice.address,
+                "Destination": bob.address,
+                "Amount": "1000000",
+                "Fee": "10",
+                "Sequence": 0,
+                "TicketSequence": 1,
+                "FirstLedgerSequence": current_seq + 1,
+                "LastLedgerSequence": current_seq + 10,
+                "Flags": 2147483648,
+                "SigningPubKey": "",
+            },
+        },
+        alice.wallet,
+        timeout=60,
+    )
+
+    export_seq = ctx.validated_ledger_index(0)
+    engine_result = result.get("engine_result", "")
+    log(f"Export completed at ledger {export_seq}, result: {engine_result}")
+
+    if engine_result != "tesSUCCESS":
+        raise AssertionError(
+            f"Expected tesSUCCESS for export, got {engine_result}"
+        )
+
+    # Assert ExportResult is well-formed with signers
+    meta = result.get("meta", {})
+    assert_export_result(meta, log, require_signers=True)
+
+    # Assert shadow ticket was created
+    assert_shadow_ticket(ctx, alice.address, log, expect_exists=True)
+
+    # --- 2. Submit Payment from same account ---
+    log("Submitting payment from alice to bob...")
+    pay_result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Payment",
+            "Destination": bob.address,
+            "Amount": "1000000",
+            "Fee": "12",
+        },
+        alice.wallet,
+        timeout=30,
+    )
+
+    pay_engine = pay_result.get("engine_result", "")
+    log(f"Payment result: {pay_engine}")
+
+    if pay_engine != "tesSUCCESS":
+        raise AssertionError(f"Payment failed: {pay_engine}")
+
+    log(
+        f"Both transactions succeeded: "
+        f"Export at ledger {export_seq}, Payment at ledger {ctx.validated_ledger_index(0)}"
+    )
+    log("Sequence handling OK - export didn't block subsequent txns")
+    log("PASS")

.testnet/scenarios/export/steady_state_export.py

@@ -0,0 +1,211 @@
+""":descr: install xport hook, trigger export, verify emitted ttEXPORT lifecycle
+
+  1. Fund alice (hook holder), bob (trigger), carol (export destination)
+  2. Install xport hook on alice
+  3. bob pays alice with DST=carol → hook calls xport() → emits ttEXPORT
+  4. Emitted ttEXPORT enters open ledger, validators attach sigs via proposals
+  5. Verify Export transaction appears in a subsequent ledger
+"""
+
+from __future__ import annotations
+
+from export_helpers import (
+    require_export,
+    find_export_txns,
+    dst_param,
+    assert_hook_accepted,
+    assert_export_result,
+    assert_shadow_ticket,
+)
+
+# C source for the xport hook — verbatim from src/test/app/Export_test_hooks.h
+# On Payment to the hook account, exports a 1 XAH payment to the DST param.
+XPORT_HOOK_C = r"""
+#include <stdint.h>
+extern int32_t _g(uint32_t id, uint32_t maxiter);
+extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
+extern int64_t rollback(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
+extern int64_t xport(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
+extern int64_t xport_reserve(uint32_t count);
+extern int64_t hook_account(uint32_t write_ptr, uint32_t write_len);
+extern int64_t otxn_param(uint32_t write_ptr, uint32_t write_len, uint32_t name_ptr, uint32_t name_len);
+extern int64_t otxn_type(void);
+extern int64_t ledger_seq(void);
+
+#define SBUF(x) (uint32_t)(x), sizeof(x)
+#define ASSERT(x) if (!(x)) rollback((uint32_t)#x, sizeof(#x), __LINE__)
+
+#define ttPAYMENT 0
+#define tfCANONICAL 0x80000000UL
+#define amAMOUNT 1
+#define amFEE 8
+#define atACCOUNT 1
+#define atDESTINATION 3
+
+#define ENCODE_TT(buf_out, tt) \
+    buf_out[0] = 0x12U; buf_out[1] = (tt >> 8) & 0xFFU; buf_out[2] = tt & 0xFFU; buf_out += 3;
+
+#define ENCODE_FLAGS(buf_out, flags) \
+    buf_out[0] = 0x22U; buf_out[1] = (flags >> 24) & 0xFFU; buf_out[2] = (flags >> 16) & 0xFFU; \
+    buf_out[3] = (flags >> 8) & 0xFFU; buf_out[4] = flags & 0xFFU; buf_out += 5;
+
+#define ENCODE_SEQUENCE(buf_out, seq) \
+    buf_out[0] = 0x24U; buf_out[1] = (seq >> 24) & 0xFFU; buf_out[2] = (seq >> 16) & 0xFFU; \
+    buf_out[3] = (seq >> 8) & 0xFFU; buf_out[4] = seq & 0xFFU; buf_out += 5;
+
+#define ENCODE_FLS(buf_out, fls) \
+    buf_out[0] = 0x20U; buf_out[1] = 0x1AU; buf_out[2] = (fls >> 24) & 0xFFU; \
+    buf_out[3] = (fls >> 16) & 0xFFU; buf_out[4] = (fls >> 8) & 0xFFU; \
+    buf_out[5] = fls & 0xFFU; buf_out += 6;
+
+#define ENCODE_LLS(buf_out, lls) \
+    buf_out[0] = 0x20U; buf_out[1] = 0x1BU; buf_out[2] = (lls >> 24) & 0xFFU; \
+    buf_out[3] = (lls >> 16) & 0xFFU; buf_out[4] = (lls >> 8) & 0xFFU; \
+    buf_out[5] = lls & 0xFFU; buf_out += 6;
+
+#define ENCODE_DROPS(buf_out, drops, amt_type) \
+    buf_out[0] = 0x60U + amt_type; buf_out[1] = 0x40U + ((drops >> 56) & 0x3FU); \
+    buf_out[2] = (drops >> 48) & 0xFFU; buf_out[3] = (drops >> 40) & 0xFFU; \
+    buf_out[4] = (drops >> 32) & 0xFFU; buf_out[5] = (drops >> 24) & 0xFFU; \
+    buf_out[6] = (drops >> 16) & 0xFFU; buf_out[7] = (drops >> 8) & 0xFFU; \
+    buf_out[8] = drops & 0xFFU; buf_out += 9;
+
+#define ENCODE_SIGNING_PUBKEY_EMPTY(buf_out) \
+    buf_out[0] = 0x73U; buf_out[1] = 0x00U; buf_out += 2;
+
+#define ENCODE_ACCOUNT(buf_out, acc, acc_type) \
+    buf_out[0] = 0x80U + acc_type; buf_out[1] = 0x14U; \
+    for (int i = 0; i < 20; ++i) buf_out[2+i] = acc[i]; buf_out += 22;
+
+#define PREPARE_PAYMENT_SIMPLE_SIZE 270U
+
+int64_t hook(uint32_t reserved) {
+    _g(1, 1);
+
+    if (otxn_type() != ttPAYMENT)
+        return accept(0, 0, 0);
+
+    ASSERT(xport_reserve(1) == 1);
+
+    uint8_t dst[20];
+    int64_t dst_len = otxn_param(SBUF(dst), "DST", 3);
+    ASSERT(dst_len == 20);
+
+    uint8_t acc[20];
+    ASSERT(hook_account(SBUF(acc)) == 20);
+
+    uint32_t cls = (uint32_t)ledger_seq();
+
+    uint8_t tx[PREPARE_PAYMENT_SIMPLE_SIZE];
+    uint8_t* buf = tx;
+
+    ENCODE_TT(buf, ttPAYMENT);
+    ENCODE_FLAGS(buf, tfCANONICAL);
+    ENCODE_SEQUENCE(buf, 0);
+    ENCODE_FLS(buf, cls + 1);
+    ENCODE_LLS(buf, cls + 5);
+    // sfTicketSequence = UINT32 field 41 = 0x20 0x29
+    buf[0] = 0x20U; buf[1] = 0x29U;
+    buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 1;
+    buf += 6;
+
+    uint64_t drops = 1000000;
+    ENCODE_DROPS(buf, drops, amAMOUNT);
+    ENCODE_DROPS(buf, 10, amFEE);
+
+    ENCODE_SIGNING_PUBKEY_EMPTY(buf);
+    ENCODE_ACCOUNT(buf, acc, atACCOUNT);
+    ENCODE_ACCOUNT(buf, dst, atDESTINATION);
+
+    uint8_t hash[32];
+    int64_t xport_result = xport(SBUF(hash), (uint32_t)tx, buf - tx);
+    ASSERT(xport_result == 32);
+
+    return accept(0, 0, 0);
+}
+"""
+
+
+async def scenario(ctx, log):
+    # Wait for network to start and amendments to activate
+    await require_export(ctx, log)
+
+    # --- Setup ---
+    await ctx.fund_accounts({"alice": 10000, "bob": 10000, "carol": 1000})
+    log("Accounts funded")
+
+    alice = ctx.account("alice")
+    carol = ctx.account("carol")
+
+    # Compile and install xport hook on alice
+    wasm = ctx.compile_hook(XPORT_HOOK_C, label="xport")
+    await ctx.submit_and_wait(
+        {
+            "TransactionType": "SetHook",
+            "Hooks": [
+                {
+                    "Hook": {
+                        "CreateCode": wasm.hex().upper(),
+                        "HookOn": "0" * 64,
+                        "HookNamespace": "0" * 64,
+                        "HookApiVersion": 0,
+                        "Flags": 1,  # hsfOVERRIDE
+                    }
+                }
+            ],
+            "Fee": "100000000",
+        },
+        alice.wallet,
+    )
+    log(
+        f"Hook installed on alice ({alice.address[:12]}...) "
+        f"ledger {ctx.validated_ledger_index(0)}"
+    )
+
+    # --- Trigger ---
+    # bob pays alice → hook calls xport() → emits ttEXPORT
+    trigger_result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Payment",
+            "Destination": alice.address,
+            "Amount": "100000000",
+            "Fee": "1000000",
+            "HookParameters": [dst_param(carol.address)],
+        },
+        ctx.account("bob").wallet,
+    )
+    trigger_seq = ctx.validated_ledger_index(0)
+    log(f"Export triggered at ledger {trigger_seq}")
+
+    # Assert hook fired with ACCEPT and emitted 1 tx
+    trigger_meta = trigger_result.get("meta", {})
+    assert_hook_accepted(trigger_meta, log, expected_emits=1)
+
+    # --- Verify: check each ledger close for the Export transaction ---
+    max_ledgers = 10
+    for i in range(max_ledgers):
+        await ctx.wait_for_ledgers(1, node_id=0, timeout=30)
+        seq = ctx.validated_ledger_index(0)
+        exports = find_export_txns(ctx, seq)
+        if exports:
+            export_tx = exports[0]
+            meta = export_tx.get("meta", export_tx.get("metaData", {}))
+            result = meta.get("TransactionResult", "")
+            log(f"Ledger {seq}: Export txn found, result={result}")
+
+            if result != "tesSUCCESS":
+                raise AssertionError(f"Export did not succeed: {result}")
+
+            # Assert ExportResult is well-formed with signers and inner tx
+            assert_export_result(meta, log, require_signers=True)
+
+            # Assert shadow ticket was created
+            assert_shadow_ticket(ctx, alice.address, log, expect_exists=True)
+
+            log("PASS")
+            return
+        log(f"Ledger {seq}: no Export txn yet")
+
+    raise AssertionError(
+        f"No Export transaction found after {max_ledgers} ledger closes"
+    )

.testnet/scenarios/helpers.py

@@ -0,0 +1,60 @@
+"""Shared helpers for ConsensusEntropy scenario tests."""
+
+from __future__ import annotations
+
+ZERO_DIGEST = "0" * 64
+
+
+async def require_entropy(ctx, log):
+    """Wait for first ledger and assert ConsensusEntropy is enabled."""
+    await ctx.wait_for_ledger_close(timeout=120)
+    feature = ctx.feature_check("ConsensusEntropy", node_id=0)
+    if not feature or not feature.get("enabled", False):
+        raise AssertionError(f"ConsensusEntropy not enabled: {feature}")
+    log("ConsensusEntropy enabled")
+
+
+def get_entropy_tx(ctx, seq):
+    """Fetch ledger and return (ce_tx, user_txns) or raise."""
+    result = ctx.ledger(seq, transactions=True)
+    if not result:
+        raise AssertionError(f"Ledger {seq}: fetch failed")
+
+    txns = result.get("ledger", {}).get("transactions", [])
+    ce = [tx for tx in txns if tx.get("TransactionType") == "ConsensusEntropy"]
+    user = [tx for tx in txns if tx.get("TransactionType") != "ConsensusEntropy"]
+
+    if len(ce) != 1:
+        raise AssertionError(
+            f"Ledger {seq}: expected 1 ConsensusEntropy txn, got {len(ce)}"
+        )
+
+    return ce[0], user
+
+
+def entropy_fields(ce_tx):
+    """Return (digest, entropy_count, is_zero) from a ConsensusEntropy tx."""
+    digest = ce_tx.get("Digest", "")
+    entropy_count = ce_tx.get("EntropyCount", -1)
+    is_zero = digest == ZERO_DIGEST and entropy_count == 0
+    return digest, entropy_count, is_zero
+
+
+def assert_valid_entropy(ce_tx, seq, seen_digests=None):
+    """Assert non-zero quorum-met entropy. Optionally check uniqueness."""
+    digest, entropy_count, is_zero = entropy_fields(ce_tx)
+
+    if is_zero or not digest:
+        raise AssertionError(f"Ledger {seq}: zero/empty Digest")
+
+    if entropy_count < 4:
+        raise AssertionError(
+            f"Ledger {seq}: EntropyCount={entropy_count} < 4 (sub-quorum)"
+        )
+
+    if seen_digests is not None:
+        if digest in seen_digests:
+            raise AssertionError(f"Ledger {seq}: duplicate Digest {digest[:16]}...")
+        seen_digests.add(digest)
+
+    return digest, entropy_count

.testnet/scenarios/suite.yml

@@ -0,0 +1,42 @@
+defaults:
+  network:
+    node_count: 5
+    launcher: tmux
+    slave_delay: 0.2
+    features:
+      - ConsensusEntropy
+    track_features:
+      - ConsensusEntropy
+    log_levels:
+      TxQ: info
+      Protocol: debug
+      Peer: debug
+      LedgerConsensus: debug
+      NetworkOPs: info
+    env:
+      XAHAU_RESOURCE_PER_PORT: "1"
+      XAHAU_RNG_POLL_MS: "333"
+
+tests:
+  - name: steady_state_entropy
+    script: .testnet/scenarios/entropy/steady_state_entropy.py
+
+  - name: steady_state_entropy_fast_start
+    script: .testnet/scenarios/entropy/steady_state_entropy.py
+    network:
+      env:
+        XAHAUD_BOOTSTRAP_FAST_START: "1"
+
+  - name: entropy_with_transactions
+    script: .testnet/scenarios/entropy/entropy_with_transactions.py
+
+  - name: quorum_recovery_smoke
+    script: .testnet/scenarios/entropy/quorum_recovery_smoke.py
+
+  - name: quorum_degradation_smoke
+    script: .testnet/scenarios/entropy/quorum_degradation_smoke.py
+    network:
+      log_levels:
+        LedgerConsensus: trace
+
+  # Export scenarios: see export-suite.yml

API-CHANGELOG.md

@@ -83,17 +83,9 @@ The [commandline](https://xrpl.org/docs/references/http-websocket-apis/api-conve
 
 The `network_id` field was added in the `server_info` response in version 1.5.0 (2019), but it is not returned in [reporting mode](https://xrpl.org/rippled-server-modes.html#reporting-mode). However, use of reporting mode is now discouraged, in favor of using [Clio](https://github.com/XRPLF/clio) instead.
 
-## XRP Ledger server version 2.5.0
-
-As of 2025-04-04, version 2.5.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
-
-### Additions and bugfixes in 2.5.0
-
-- `channel_authorize`: If `signing_support` is not enabled in the config, the RPC is disabled.
-
 ## XRP Ledger server version 2.4.0
 
-[Version 2.4.0](https://github.com/XRPLF/rippled/releases/tag/2.4.0) was released on March 4, 2025.
+As of 2025-01-28, version 2.4.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
 
 ### Additions and bugfixes in 2.4.0
 

BUILD.md

@@ -182,6 +182,16 @@ which allows you to statically link it with GCC, if you want.
    conan export external/snappy --version 1.1.10 --user xahaud --channel stable
    ```
 
+Export our [Conan recipe for RocksDB](./external/rocksdb).
+It does not override paths to dependencies when building with Visual Studio.
+
+   ```
+   # Conan 1.x
+   conan export external/rocksdb rocksdb/6.29.5@
+   # Conan 2.x
+   conan export --version 6.29.5 external/rocksdb
+   ```
+
 Export our [Conan recipe for SOCI](./external/soci).
 It patches their CMake to correctly import its dependencies.
 
@@ -195,6 +205,17 @@ It patches their CMake to correctly import its dependencies.
    conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable
    ```
 
+Export our [Conan recipe for NuDB](./external/nudb).
+It fixes some source files to add missing `#include`s.
+
+
+   ```
+   # Conan 1.x
+   conan export external/nudb nudb/2.0.8@
+   # Conan 2.x
+   conan export --version 2.0.8 external/nudb
+   ```
+
 ### Build and Test
 
 1. Create a build directory and move into it.
@@ -280,7 +301,7 @@ It patches their CMake to correctly import its dependencies.
    Single-config generators:
 
    ```
-   cmake --build . -j $(nproc)
+   cmake --build .
    ```
 
    Multi-config generators:

Builds/levelization/README.md

@@ -59,6 +59,10 @@ the rippled source. The only caveat is that it runs much slower
 under Windows than in Linux. It hasn't yet been tested under MacOS.
 It generates many files of [results](results):
 
+For local iteration speed there is also
+[levelization.py](levelization.py), which generates the same artifact set much
+faster. The shell script remains canonical for CI/auditing.
+
 * `rawincludes.txt`: The raw dump of the `#includes`
 * `paths.txt`: A second dump grouping the source module
   to the destination module, deduped, and with frequency counts.
@@ -109,6 +113,9 @@ prevent false alarms and merging issues, and because it's easy to
 get those details locally.
 
 1. Run `levelization.sh`
+   * Faster local loop: `python3 Builds/levelization/levelization.py`
+   * Optional parity check against canonical shell output:
+     `python3 Builds/levelization/levelization.py --results-dir /tmp/levelization-py-results --compare-to Builds/levelization/results`
 2. Grep the modules in `paths.txt`.
    * For example, if a cycle is found `A ~= B`, simply `grep -w
      A Builds/levelization/results/paths.txt | grep -w B`

Builds/levelization/levelization.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""
+Development-oriented levelization generator.
+
+This script produces the same result artifact set as levelization.sh, but is
+much faster by doing parsing/counting in-process instead of spawning many
+external tools in tight loops.
+
+The shell script remains the canonical CI path. Use this script for local
+iteration speed, then run levelization.sh before committing if you need strict
+parity with existing workflow.
+"""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import os
+import posixpath
+import re
+import shutil
+import time
+from collections import Counter, defaultdict
+from pathlib import Path
+
+INCLUDE_PATTERN = re.compile(r"^\s*#include.*/.*\.h")
+INCLUDE_TARGET_PATTERN = re.compile(r'.*["<]([^">]+)[">].*')
+PATHS_LINE_PATTERN = re.compile(r"^\s*(\d+)\s+(\S+)\s+(\S+)\s*$")
+
+
+def dictionary_sort_key(value: str) -> str:
+    """Approximate `sort -d` behavior used by the shell script."""
+    return "".join(ch for ch in value if ch.isalnum() or ch.isspace())
+
+
+def normalize_level(value: str) -> str:
+    # Match shell behavior: if level includes a file component (contains "."),
+    # replace with dirname + "/toplevel".
+    if "." in value:
+        parent = posixpath.dirname(value) or "."
+        value = f"{parent}/toplevel"
+    return value.replace("/", ".")
+
+
+def source_level(rel_path: str) -> str:
+    parts = rel_path.split("/")
+    return normalize_level("/".join(parts[1:3]))
+
+
+def include_level(include_line: str) -> str | None:
+    match = INCLUDE_TARGET_PATTERN.match(include_line)
+    if not match:
+        return None
+    include_path = match.group(1)
+    parts = include_path.split("/")
+    return normalize_level("/".join(parts[:2]))
+
+
+def scan_file(path: Path, repo_root: Path) -> tuple[list[str], list[tuple[str, str]]]:
+    rel = path.relative_to(repo_root).as_posix()
+    src_level = source_level(rel)
+
+    raw_lines: list[str] = []
+    paths: list[tuple[str, str]] = []
+
+    with path.open("r", encoding="utf-8", errors="ignore") as handle:
+        for line in handle:
+            if "boost" in line:
+                continue
+            if not INCLUDE_PATTERN.match(line):
+                continue
+
+            line = line.rstrip("\n")
+            raw_lines.append(f"{rel}:{line}")
+
+            dst_level = include_level(line)
+            if dst_level is None:
+                continue
+            if src_level != dst_level:
+                paths.append((src_level, dst_level))
+
+    return raw_lines, paths
+
+
+def iter_source_files(repo_root: Path) -> list[Path]:
+    files: list[Path] = []
+    for top in ("include", "src"):
+        root = repo_root / top
+        files.extend(path for path in root.rglob("*") if path.is_file())
+    files.sort(key=lambda p: p.relative_to(repo_root).as_posix())
+    return files
+
+
+def write_relation_db(
+    results_dir: Path,
+    edge_counts: list[tuple[tuple[str, str], int]],
+) -> tuple[dict[str, list[tuple[str, int]]], dict[str, list[tuple[str, int]]]]:
+    includes_dir = results_dir / "includes"
+    includedby_dir = results_dir / "includedby"
+    includes_dir.mkdir(parents=True, exist_ok=True)
+    includedby_dir.mkdir(parents=True, exist_ok=True)
+
+    includes: dict[str, list[tuple[str, int]]] = defaultdict(list)
+    includedby: dict[str, list[tuple[str, int]]] = defaultdict(list)
+
+    with (results_dir / "paths.txt").open("w", encoding="utf-8") as out:
+        for (src, dst), count in edge_counts:
+            out.write(f"{count:7d} {src} {dst}\n")
+            includes[src].append((dst, count))
+            includedby[dst].append((src, count))
+
+    for src, entries in includes.items():
+        with (includes_dir / src).open("w", encoding="utf-8") as out:
+            for dst, count in entries:
+                out.write(f"{dst} {count}\n")
+
+    for dst, entries in includedby.items():
+        with (includedby_dir / dst).open("w", encoding="utf-8") as out:
+            for src, count in entries:
+                out.write(f"{src} {count}\n")
+
+    return includes, includedby
+
+
+def build_loops_and_ordering(
+    includes: dict[str, list[tuple[str, int]]],
+) -> tuple[list[str], list[str]]:
+    include_map = {
+        src: {dst: count for dst, count in entries}
+        for src, entries in includes.items()
+    }
+
+    ordering_lines: list[str] = []
+    loops_lines: list[str] = []
+
+    seen_pairs: set[tuple[str, str]] = set()
+
+    for source in sorted(includes.keys()):
+        for include, includefreq in includes[source]:
+            if include not in include_map:
+                continue
+
+            sourcefreq = include_map[include].get(source)
+            if sourcefreq is None:
+                ordering_lines.append(f"{source} > {include}\n")
+                continue
+
+            if (include, source) in seen_pairs:
+                continue
+            seen_pairs.add((source, include))
+
+            loops_lines.append(f"Loop: {source} {include}\n")
+            if includefreq - sourcefreq > 3:
+                loops_lines.append(f"  {source} > {include}\n\n")
+            elif sourcefreq - includefreq > 3:
+                loops_lines.append(f"  {include} > {source}\n\n")
+            elif sourcefreq == includefreq:
+                loops_lines.append(f"  {include} == {source}\n\n")
+            else:
+                loops_lines.append(f"  {include} ~= {source}\n\n")
+
+    return ordering_lines, loops_lines
+
+
+def parse_paths(path: Path) -> dict[tuple[str, str], int]:
+    out: dict[tuple[str, str], int] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        match = PATHS_LINE_PATTERN.match(line)
+        if not match:
+            raise ValueError(f"Cannot parse paths line: {line!r}")
+        count = int(match.group(1))
+        src = match.group(2)
+        dst = match.group(3)
+        out[(src, dst)] = count
+    return out
+
+
+def parse_relation_dir(path: Path) -> dict[str, Counter[str]]:
+    out: dict[str, Counter[str]] = {}
+    if not path.exists():
+        return out
+    for file in sorted(p for p in path.iterdir() if p.is_file()):
+        lines = [line for line in file.read_text(encoding="utf-8").splitlines() if line]
+        out[file.name] = Counter(lines)
+    return out
+
+
+def compare_results(generated: Path, canonical: Path) -> list[str]:
+    mismatches: list[str] = []
+
+    # rawincludes: compare as sets/multisets of lines to ignore traversal order.
+    gen_raw = Counter(generated.joinpath("rawincludes.txt").read_text(encoding="utf-8").splitlines())
+    can_raw = Counter(canonical.joinpath("rawincludes.txt").read_text(encoding="utf-8").splitlines())
+    if gen_raw != can_raw:
+        mismatches.append("rawincludes.txt differs (line multiset mismatch)")
+
+    # paths: compare parsed edge->count map, ignoring ordering/whitespace.
+    gen_paths = parse_paths(generated / "paths.txt")
+    can_paths = parse_paths(canonical / "paths.txt")
+    if gen_paths != can_paths:
+        mismatches.append("paths.txt differs (edge count mismatch)")
+
+    # includes / includedby: compare per-file line multisets.
+    for rel in ("includes", "includedby"):
+        gen_rel = parse_relation_dir(generated / rel)
+        can_rel = parse_relation_dir(canonical / rel)
+        if gen_rel != can_rel:
+            mismatches.append(f"{rel}/ differs (file set or content mismatch)")
+
+    # ordering and loops are canonical artifacts; require exact bytes.
+    for name in ("ordering.txt", "loops.txt"):
+        gen_text = generated.joinpath(name).read_text(encoding="utf-8")
+        can_text = canonical.joinpath(name).read_text(encoding="utf-8")
+        if gen_text != can_text:
+            mismatches.append(f"{name} differs")
+
+    return mismatches
+
+
+def generate(results_dir: Path, repo_root: Path, workers: int) -> None:
+    if results_dir.exists():
+        shutil.rmtree(results_dir)
+    results_dir.mkdir(parents=True)
+
+    files = iter_source_files(repo_root)
+
+    raw_by_file: dict[str, list[str]] = {}
+    paths_by_file: dict[str, list[tuple[str, str]]] = {}
+
+    start = time.perf_counter()
+    if workers <= 1:
+        for file in files:
+            rel = file.relative_to(repo_root).as_posix()
+            raw, paths = scan_file(file, repo_root)
+            raw_by_file[rel] = raw
+            paths_by_file[rel] = paths
+    else:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool:
+            futures = {
+                file.relative_to(repo_root).as_posix(): pool.submit(
+                    scan_file, file, repo_root
+                )
+                for file in files
+            }
+            for rel in sorted(futures.keys()):
+                raw, paths = futures[rel].result()
+                raw_by_file[rel] = raw
+                paths_by_file[rel] = paths
+
+    raw_lines: list[str] = []
+    raw_lines.extend(
+        line
+        for rel in sorted(raw_by_file.keys())
+        for line in raw_by_file[rel]
+    )
+    with (results_dir / "rawincludes.txt").open("w", encoding="utf-8") as out:
+        out.write("\n".join(raw_lines))
+        if raw_lines:
+            out.write("\n")
+
+    path_pairs: list[tuple[str, str]] = []
+    path_pairs.extend(
+        pair
+        for rel in sorted(paths_by_file.keys())
+        for pair in paths_by_file[rel]
+    )
+    counts = Counter(path_pairs)
+
+    edge_counts = sorted(
+        counts.items(),
+        key=lambda item: (
+            dictionary_sort_key(f"{item[0][0]} {item[0][1]}"),
+            item[0][0],
+            item[0][1],
+        ),
+    )
+
+    includes, _ = write_relation_db(results_dir, edge_counts)
+    ordering, loops = build_loops_and_ordering(includes)
+
+    with (results_dir / "ordering.txt").open("w", encoding="utf-8") as out:
+        out.writelines(ordering)
+    with (results_dir / "loops.txt").open("w", encoding="utf-8") as out:
+        out.writelines(loops)
+
+    elapsed = time.perf_counter() - start
+    print(
+        f"levelization.py: scanned {len(files)} files, "
+        f"{len(raw_lines)} includes, {len(edge_counts)} unique paths in "
+        f"{elapsed:.2f}s"
+    )
+    print((results_dir / "ordering.txt").read_text(encoding="utf-8"), end="")
+    print((results_dir / "loops.txt").read_text(encoding="utf-8"), end="")
+
+
+def explain_edge(src_level: str, dst_level: str, repo_root: Path, workers: int) -> None:
+    """Show every source file and #include line that creates a dependency edge."""
+    files = iter_source_files(repo_root)
+
+    matches: list[tuple[str, str]] = []  # (source_file, include_line)
+
+    def check_file(path: Path) -> list[tuple[str, str]]:
+        rel = path.relative_to(repo_root).as_posix()
+        sl = source_level(rel)
+        if sl != src_level:
+            return []
+        hits: list[tuple[str, str]] = []
+        with path.open("r", encoding="utf-8", errors="ignore") as handle:
+            for line in handle:
+                if "boost" in line:
+                    continue
+                if not INCLUDE_PATTERN.match(line):
+                    continue
+                line = line.rstrip("\n")
+                dl = include_level(line)
+                if dl == dst_level:
+                    hits.append((rel, line.strip()))
+        return hits
+
+    if workers <= 1:
+        for file in files:
+            matches.extend(check_file(file))
+    else:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool:
+            for result in pool.map(check_file, files):
+                matches.extend(result)
+
+    if not matches:
+        print(f"No includes found from {src_level} -> {dst_level}")
+        return
+
+    print(f"{src_level} > {dst_level}  ({len(matches)} include(s)):\n")
+    for source_file, include_line in matches:
+        print(f"  {source_file}")
+        print(f"    {include_line}")
+    print()
+
+
+def main() -> int:
+    script_dir = Path(__file__).resolve().parent
+    repo_root = script_dir.parents[1]
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=repo_root,
+        help="Repository root (defaults based on script location).",
+    )
+    parser.add_argument(
+        "--results-dir",
+        type=Path,
+        default=script_dir / "results",
+        help="Output results directory.",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=min(32, (os.cpu_count() or 1)),
+        help="Thread count for source scanning (default: CPU count, max 32).",
+    )
+    parser.add_argument(
+        "--compare-to",
+        type=Path,
+        default=None,
+        help=(
+            "Compare generated results against this directory and exit non-zero "
+            "on mismatch (semantic comparison for rawincludes/paths/includes)."
+        ),
+    )
+    parser.add_argument(
+        "--explain",
+        nargs=2,
+        metavar=("SRC", "DST"),
+        default=None,
+        help=(
+            "Show which source files cause a dependency edge. "
+            "Example: --explain test.csf xrpld.app"
+        ),
+    )
+    args = parser.parse_args()
+
+    if args.explain is not None:
+        explain_edge(args.explain[0], args.explain[1], args.repo_root.resolve(), max(1, args.workers))
+        return 0
+
+    generated_dir = args.results_dir.resolve()
+    generate(
+        results_dir=generated_dir,
+        repo_root=args.repo_root.resolve(),
+        workers=max(1, args.workers),
+    )
+
+    if args.compare_to is not None:
+        canonical_dir = args.compare_to.resolve()
+        mismatches = compare_results(generated_dir, canonical_dir)
+        if mismatches:
+            print("levelization.py: mismatch against canonical results:")
+            for mismatch in mismatches:
+                print(f"  - {mismatch}")
+            return 1
+        print("levelization.py: matches canonical results")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Builds/levelization/levelization.sh

@@ -7,7 +7,7 @@
 
 pushd $( dirname $0 )
 
-if [ -v PS1 ]
+if [[ -n "${PS1-}" ]]
 then
   # if the shell is interactive, clean up any flotsam before analyzing
   git clean -ix

Builds/levelization/results/loops.txt

@@ -26,10 +26,10 @@ Loop: xrpld.app xrpld.nodestore
   xrpld.app > xrpld.nodestore
 
 Loop: xrpld.app xrpld.overlay
-  xrpld.overlay > xrpld.app
+  xrpld.overlay ~= xrpld.app
 
 Loop: xrpld.app xrpld.peerfinder
-  xrpld.peerfinder ~= xrpld.app
+  xrpld.app > xrpld.peerfinder
 
 Loop: xrpld.app xrpld.rpc
   xrpld.rpc > xrpld.app
@@ -44,10 +44,10 @@ Loop: xrpld.core xrpld.perflog
   xrpld.perflog == xrpld.core
 
 Loop: xrpld.net xrpld.rpc
-  xrpld.rpc ~= xrpld.net
+  xrpld.rpc > xrpld.net
 
 Loop: xrpld.overlay xrpld.rpc
-  xrpld.rpc ~= xrpld.overlay
+  xrpld.rpc > xrpld.overlay
 
 Loop: xrpld.perflog xrpld.rpc
   xrpld.rpc ~= xrpld.perflog

Builds/levelization/results/ordering.txt

@@ -7,7 +7,6 @@ libxrpl.protocol > xrpl.hook
 libxrpl.protocol > xrpl.json
 libxrpl.protocol > xrpl.protocol
 libxrpl.resource > xrpl.basics
-libxrpl.resource > xrpl.json
 libxrpl.resource > xrpl.resource
 libxrpl.server > xrpl.basics
 libxrpl.server > xrpl.json
@@ -62,6 +61,7 @@ test.json > test.jtx
 test.json > xrpl.json
 test.jtx > xrpl.basics
 test.jtx > xrpld.app
+test.jtx > xrpld.consensus
 test.jtx > xrpld.core
 test.jtx > xrpld.ledger
 test.jtx > xrpld.net
@@ -140,7 +140,6 @@ test.shamap > xrpl.protocol
 test.toplevel > test.csf
 test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
-tests.libxrpl > xrpl.basics
 xrpl.hook > xrpl.basics
 xrpl.hook > xrpl.protocol
 xrpl.json > xrpl.basics
@@ -169,6 +168,7 @@ xrpld.core > xrpl.basics
 xrpld.core > xrpl.json
 xrpld.core > xrpl.protocol
 xrpld.ledger > xrpl.basics
+xrpld.ledger > xrpld.core
 xrpld.ledger > xrpl.json
 xrpld.ledger > xrpl.protocol
 xrpld.net > xrpl.basics
@@ -193,6 +193,7 @@ xrpld.peerfinder > xrpld.core
 xrpld.peerfinder > xrpl.protocol
 xrpld.perflog > xrpl.basics
 xrpld.perflog > xrpl.json
+xrpld.perflog > xrpl.protocol
 xrpld.rpc > xrpl.basics
 xrpld.rpc > xrpld.core
 xrpld.rpc > xrpld.ledger

CMakeLists.txt

@@ -21,18 +21,6 @@ endif()
 project (xrpl)
 set(Boost_NO_BOOST_CMAKE ON)
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-    # GCC-specific fixes
-    add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
-    # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
-elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    # Clang-specific fixes
-    add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
-elseif(MSVC)
-    # MSVC-specific fixes
-    add_compile_options(/wd4068) # Ignore unknown pragmas
-endif()
-
 # make GIT_COMMIT_HASH define available to all sources
 find_package(Git)
 if(Git_FOUND)
@@ -109,11 +97,6 @@ set_target_properties(OpenSSL::SSL PROPERTIES
   INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
 )
 set(SECP256K1_INSTALL TRUE)
-set(SECP256K1_BUILD_BENCHMARK FALSE)
-set(SECP256K1_BUILD_TESTS FALSE)
-set(SECP256K1_BUILD_EXHAUSTIVE_TESTS FALSE)
-set(SECP256K1_BUILD_CTIME_TESTS FALSE)
-set(SECP256K1_BUILD_EXAMPLES FALSE)
 add_subdirectory(external/secp256k1)
 add_library(secp256k1::secp256k1 ALIAS secp256k1)
 add_subdirectory(external/ed25519-donna)
@@ -170,8 +153,3 @@ include(RippledCore)
 include(RippledInstall)
 include(RippledDocs)
 include(RippledValidatorKeys)
-
-if(tests)
-  include(CTest)
-  add_subdirectory(src/tests/libxrpl)
-endif()

cmake/RippledCore.cmake

@@ -68,6 +68,13 @@ target_link_libraries(xrpl.imports.main
     $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
 )
 
+# Enhanced logging can use date::make_zoned/current_zone when location-rich log
+# formatting is compiled in. Link date-tz when available so Debug builds and
+# explicit -DBEAST_ENHANCED_LOGGING=ON builds resolve those symbols.
+if(TARGET date::date-tz)
+  target_link_libraries(xrpl.imports.main INTERFACE date::date-tz)
+endif()
+
 include(add_module)
 include(target_link_modules)
 
@@ -152,9 +159,6 @@ if(xrpld)
   add_executable(rippled)
   if(tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
-    target_compile_definitions(rippled PRIVATE
-                                       UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
-    )
   endif()
   target_include_directories(rippled
     PRIVATE

cmake/RippledInterface.cmake

@@ -22,6 +22,9 @@ target_compile_definitions (opts
     $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
     $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
     $<$<BOOL:${single_io_service_thread}>:RIPPLE_SINGLE_IO_SERVICE_THREAD=1>
+    # Enhanced logging is enabled for Debug builds, or explicitly via
+    # -DBEAST_ENHANCED_LOGGING=ON for other build types.
+    $<$<OR:$<CONFIG:Debug>,$<BOOL:${BEAST_ENHANCED_LOGGING}>>:BEAST_ENHANCED_LOGGING=1>
     $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>)
 target_compile_options (opts
   INTERFACE

cmake/RippledSanity.cmake

@@ -2,7 +2,22 @@
    convenience variables and sanity checks
 #]===================================================================]
 
-get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+include(ProcessorCount)
+
+if (NOT ep_procs)
+  ProcessorCount(ep_procs)
+  if (ep_procs GREATER 1)
+    # never use more than half of cores for EP builds
+    math (EXPR ep_procs "${ep_procs} / 2")
+    message (STATUS "Using ${ep_procs} cores for ExternalProject builds.")
+  endif ()
+endif ()
+get_property (is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if (is_multiconfig STREQUAL "NOTFOUND")
+  if (${CMAKE_GENERATOR} STREQUAL "Xcode" OR ${CMAKE_GENERATOR} MATCHES "^Visual Studio")
+    set (is_multiconfig TRUE)
+  endif ()
+endif ()
 
 set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
 if (NOT is_multiconfig)

cmake/RippledSettings.cmake

@@ -11,14 +11,8 @@ option(assert "Enables asserts, even in release builds" OFF)
 option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
-if(tests)
-  # This setting allows making a separate workflow to test fees other than default 10
-  if(NOT UNIT_TEST_REFERENCE_FEE)
-    set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
-  endif()
-endif()
 
-option(unity "Creates a build using UNITY support in cmake." OFF)
+option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
 if(unity)
   if(NOT is_ci)
     set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")

cmake/deps/Boost.cmake

@@ -2,6 +2,7 @@ find_package(Boost 1.86 REQUIRED
   COMPONENTS
     chrono
     container
+    context
     coroutine
     date_time
     filesystem
@@ -24,7 +25,7 @@ endif()
 
 target_link_libraries(ripple_boost
   INTERFACE
-    Boost::headers
+    Boost::boost
     Boost::chrono
     Boost::container
     Boost::coroutine

cmake/xrpl_add_test.cmake

@@ -1,41 +0,0 @@
-include(isolate_headers)
-
-function(xrpl_add_test name)
-  set(target ${PROJECT_NAME}.test.${name})
-
-  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
-  "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
-  )
-  add_executable(${target} EXCLUDE_FROM_ALL ${ARGN} ${sources})
-
-  isolate_headers(
-    ${target}
-    "${CMAKE_SOURCE_DIR}"
-    "${CMAKE_SOURCE_DIR}/tests/${name}"
-    PRIVATE
-  )
-
-  # Make sure the test isn't optimized away in unity builds
-  set_target_properties(${target} PROPERTIES
-    UNITY_BUILD_MODE GROUP
-    UNITY_BUILD_BATCH_SIZE 0)  # Adjust as needed
-
-  add_test(NAME ${target} COMMAND ${target})
-  set_tests_properties(
-    ${target} PROPERTIES
-    FIXTURES_REQUIRED ${target}_fixture
-  )
-
-  add_test(
-    NAME ${target}.build
-    COMMAND
-      ${CMAKE_COMMAND}
-      --build ${CMAKE_BINARY_DIR}
-      --config $<CONFIG>
-      --target ${target}
-  )
-  set_tests_properties(${target}.build PROPERTIES
-    FIXTURES_SETUP ${target}_fixture
-  )
-endfunction()

conan/profiles/default

@@ -1,37 +0,0 @@
-{% set os = detect_api.detect_os() %}
-{% set arch = detect_api.detect_arch() %}
-{% set compiler, version, compiler_exe = detect_api.detect_default_compiler() %}
-{% set compiler_version = version %}
-{% if os == "Linux" %}
-{% set compiler_version = detect_api.default_compiler_version(compiler, version) %}
-{% endif %}
-
-[settings]
-os={{ os }}
-arch={{ arch }}
-build_type=Debug
-compiler={{compiler}}
-compiler.version={{ compiler_version }}
-compiler.cppstd=20
-{% if os == "Windows" %}
-compiler.runtime=static
-{% else %}
-compiler.libcxx={{detect_api.detect_libcxx(compiler, version, compiler_exe)}}
-{% endif %}
-
-[conf]
-{% if compiler == "clang" and compiler_version >= 19 %}
-tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
-{% endif %}
-{% if compiler == "apple-clang" and compiler_version >= 17 %}
-tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
-{% endif %}
-{% if compiler == "clang" and compiler_version == 16 %}
-tools.build:cxxflags=['-DBOOST_ASIO_DISABLE_CONCEPTS']
-{% endif %}
-{% if compiler == "gcc" and compiler_version < 13 %}
-tools.build:cxxflags=['-Wno-restrict']
-{% endif %}
-
-[tool_requires]
-!cmake/*: cmake/[>=3 <4]

conanfile.py

@@ -1,4 +1,4 @@
-from conan import ConanFile, __version__ as conan_version
+from conan import ConanFile
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 import re
 
@@ -26,18 +26,16 @@ class Xrpl(ConanFile):
     }
 
     requires = [
+        'date/3.0.3',
         'grpc/1.50.1',
-        'libarchive/3.8.1',
-        'nudb/2.0.9',
+        'libarchive/3.7.6',
+        'nudb/2.0.8',
         'openssl/3.6.0',
         'soci/4.0.3@xahaud/stable',
+        'xxhash/0.8.2',
         'zlib/1.3.1',
     ]
 
-    test_requires = [
-        'doctest/2.4.11',
-    ]
-
     tool_requires = [
         'protobuf/3.21.12',
     ]
@@ -93,13 +91,12 @@ class Xrpl(ConanFile):
     }
 
     def set_version(self):
-        if self.version is None:
-            path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
-            regex = r'versionString\s?=\s?\"(.*)\"'
-            with open(path, encoding='utf-8') as file:
-                matches = (re.search(regex, line) for line in file)
-                match = next(m for m in matches if m)
-                self.version = match.group(1)
+        path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
+        regex = r'versionString\s?=\s?\"(.*)\"'
+        with open(path, 'r') as file:
+            matches = (re.search(regex, line) for line in file)
+            match = next(m for m in matches if m)
+            self.version = match.group(1)
 
     def build_requirements(self):
         # These provide build tools (protoc, grpc plugins) that run during build
@@ -113,24 +110,20 @@ class Xrpl(ConanFile):
             self.options['boost/*'].visibility = 'global'
 
     def requirements(self):
-        # Conan 2 requires transitive headers to be specified
-        transitive_headers_opt = {'transitive_headers': True} if conan_version.split('.')[0] == '2' else {}
         # Force sqlite3 version to avoid conflicts with soci
-        self.requires('sqlite3/3.49.1', override=True)
-        # Force our custom snappy build to avoid Conan CMakeDeps stdc++ heuristic bug
+        self.requires('sqlite3/3.47.0', override=True)
+        # Force our custom snappy build for all dependencies
         self.requires('snappy/1.1.10@xahaud/stable', override=True)
         # Force boost version for all dependencies to avoid conflicts
-        self.requires('boost/1.86.0', force=True, **transitive_headers_opt)
-        self.requires('date/3.0.4', **transitive_headers_opt)
+        self.requires('boost/1.86.0', override=True)
         self.requires('lz4/1.10.0', force=True)
 
         if self.options.with_wasmedge:
-            self.requires('wasmedge/0.11.2@xahaud/stable', **transitive_headers_opt)
+            self.requires('wasmedge/0.11.2@xahaud/stable')
         if self.options.jemalloc:
-            self.requires('jemalloc/5.3.0', **transitive_headers_opt)
+            self.requires('jemalloc/5.3.0')
         if self.options.rocksdb:
-            self.requires('rocksdb/10.0.1')
-        self.requires('xxhash/0.8.3', **transitive_headers_opt)
+            self.requires('rocksdb/6.29.5')
 
     exports_sources = (
         'CMakeLists.txt',
@@ -185,17 +178,7 @@ class Xrpl(ConanFile):
         # `include/`, not `include/ripple/proto/`.
         libxrpl.includedirs = ['include', 'include/ripple/proto']
         libxrpl.requires = [
-            'boost::headers',
-            'boost::chrono',
-            'boost::container',
-            'boost::coroutine',
-            'boost::date_time',
-            'boost::filesystem',
-            'boost::json',
-            'boost::program_options',
-            'boost::regex',
-            'boost::system',
-            'boost::thread',
+            'boost::boost',
             'date::date',
             'grpc::grpc++',
             'libarchive::libarchive',

docs/build/environment.md

@@ -23,7 +23,7 @@ direction.
 
 ```
 apt update
-apt install --yes curl git libssl-dev pipx python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
+apt install --yes curl git libssl-dev python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
 
 curl --location --remote-name \
   "https://github.com/Kitware/CMake/releases/download/v3.25.1/cmake-3.25.1.tar.gz"
@@ -35,8 +35,7 @@ make --jobs $(nproc)
 make install
 cd ..
 
-pipx install 'conan<2'
-pipx ensurepath
+pip3 install 'conan<2'
 ```
 
 [1]: https://github.com/thejohnfreeman/rippled-docker/blob/master/ubuntu-22.04/install.sh

examples/example/CMakeLists.txt

@@ -9,7 +9,7 @@ project(
   LANGUAGES CXX
 )
 
-find_package(xrpl CONFIG REQUIRED)
+find_package(xrpl REQUIRED)
 
 add_executable(example)
 target_sources(example PRIVATE src/example.cpp)

examples/example/conanfile.py

@@ -0,0 +1,59 @@
+from conan import ConanFile, conan_version
+from conan.tools.cmake import CMake, cmake_layout
+
+class Example(ConanFile):
+
+    def set_name(self):
+        if self.name is None:
+            self.name = 'example'
+
+    def set_version(self):
+        if self.version is None:
+            self.version = '0.1.0'
+
+    license = 'ISC'
+    author = 'John Freeman <jfreeman08@gmail.com>'
+
+    settings = 'os', 'compiler', 'build_type', 'arch'
+    options = {'shared': [True, False], 'fPIC': [True, False]}
+    default_options = {
+        'shared': False,
+        'fPIC': True,
+        'xrpl:xrpld': False,
+    }
+
+    requires = ['xrpl/2.2.0-rc1@jfreeman/nodestore']
+    generators = ['CMakeDeps', 'CMakeToolchain']
+
+    exports_sources = [
+        'CMakeLists.txt',
+        'cmake/*',
+        'external/*',
+        'include/*',
+        'src/*',
+    ]
+
+    # For out-of-source build.
+    # https://docs.conan.io/en/latest/reference/build_helpers/cmake.html#configure
+    no_copy_source = True
+
+    def layout(self):
+        cmake_layout(self)
+
+    def config_options(self):
+        if self.settings.os == 'Windows':
+            del self.options.fPIC
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure(variables={'BUILD_TESTING': 'NO'})
+        cmake.build()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
+
+    def package_info(self):
+        path = f'{self.package_folder}/share/{self.name}/cpp_info.py'
+        with open(path, 'r') as file:
+            exec(file.read(), {}, {'self': self.cpp_info})

examples/example/src/example.cpp

@@ -1,10 +1,8 @@
-#include <xrpl/protocol/BuildInfo.h>
-
 #include <cstdio>
 
-int
-main(int argc, char const** argv)
-{
+#include <xrpl/protocol/BuildInfo.h>
+
+int main(int argc, char const** argv) {
     std::printf("%s\n", ripple::BuildInfo::getVersionString().c_str());
     return 0;
 }

external/antithesis-sdk/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.25)
 
 # Note, version set explicitly by rippled project
 project(antithesis-sdk-cpp VERSION 0.4.4 LANGUAGES CXX)

external/nudb/conandata.yml

@@ -0,0 +1,10 @@
+sources:
+  "2.0.8":
+    url: "https://github.com/CPPAlliance/NuDB/archive/2.0.8.tar.gz"
+    sha256: "9b71903d8ba111cd893ab064b9a8b6ac4124ed8bd6b4f67250205bc43c7f13a8"
+patches:
+  "2.0.8":
+    - patch_file: "patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch"
+      patch_description: "Fix build for MSVC by including stdexcept"
+      patch_type: "portability"
+      patch_source: "https://github.com/cppalliance/NuDB/pull/100/files"

external/nudb/conanfile.py

@@ -0,0 +1,72 @@
+import os
+
+from conan import ConanFile
+from conan.tools.build import check_min_cppstd
+from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get
+from conan.tools.layout import basic_layout
+
+required_conan_version = ">=1.52.0"
+
+
+class NudbConan(ConanFile):
+    name = "nudb"
+    description = "A fast key/value insert-only database for SSD drives in C++11"
+    license = "BSL-1.0"
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://github.com/CPPAlliance/NuDB"
+    topics = ("header-only", "KVS", "insert-only")
+
+    package_type = "header-library"
+    settings = "os", "arch", "compiler", "build_type"
+    no_copy_source = True
+
+    @property
+    def _min_cppstd(self):
+        return 11
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def layout(self):
+        basic_layout(self, src_folder="src")
+
+    def requirements(self):
+        self.requires("boost/1.83.0")
+
+    def package_id(self):
+        self.info.clear()
+
+    def validate(self):
+        if self.settings.compiler.cppstd:
+            check_min_cppstd(self, self._min_cppstd)
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def build(self):
+        apply_conandata_patches(self)
+
+    def package(self):
+        copy(self, "LICENSE*",
+             dst=os.path.join(self.package_folder, "licenses"),
+             src=self.source_folder)
+        copy(self, "*",
+             dst=os.path.join(self.package_folder, "include"),
+             src=os.path.join(self.source_folder, "include"))
+
+    def package_info(self):
+        self.cpp_info.bindirs = []
+        self.cpp_info.libdirs = []
+
+        self.cpp_info.set_property("cmake_target_name", "NuDB")
+        self.cpp_info.set_property("cmake_target_aliases", ["NuDB::nudb"])
+        self.cpp_info.set_property("cmake_find_mode", "both")
+
+        self.cpp_info.components["core"].set_property("cmake_target_name", "nudb")
+        self.cpp_info.components["core"].names["cmake_find_package"] = "nudb"
+        self.cpp_info.components["core"].names["cmake_find_package_multi"] = "nudb"
+        self.cpp_info.components["core"].requires = ["boost::thread", "boost::system"]
+
+        # TODO: to remove in conan v2 once cmake_find_package_* generators removed
+        self.cpp_info.names["cmake_find_package"] = "NuDB"
+        self.cpp_info.names["cmake_find_package_multi"] = "NuDB"

external/nudb/patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch

@@ -0,0 +1,24 @@
+diff --git a/include/nudb/detail/stream.hpp b/include/nudb/detail/stream.hpp
+index 6c07bf1..e0ce8ed 100644
+--- a/include/nudb/detail/stream.hpp
++++ b/include/nudb/detail/stream.hpp
+@@ -14,6 +14,7 @@
+ #include <cstdint>
+ #include <cstring>
+ #include <memory>
++#include <stdexcept>
+ 
+ namespace nudb {
+ namespace detail {
+diff --git a/include/nudb/impl/context.ipp b/include/nudb/impl/context.ipp
+index beb7058..ffde0b3 100644
+--- a/include/nudb/impl/context.ipp
++++ b/include/nudb/impl/context.ipp
+@@ -9,6 +9,7 @@
+ #define NUDB_IMPL_CONTEXT_IPP
+ 
+ #include <nudb/detail/store_base.hpp>
++#include <stdexcept>
+ 
+ namespace nudb {
+ 

external/rocksdb/conandata.yml

@@ -0,0 +1,27 @@
+sources:
+  "6.29.5":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.29.5.tar.gz"
+    sha256: "ddbf84791f0980c0bbce3902feb93a2c7006f6f53bfd798926143e31d4d756f0"
+  "6.27.3":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.27.3.tar.gz"
+    sha256: "ee29901749b9132692b26f0a6c1d693f47d1a9ed8e3771e60556afe80282bf58"
+  "6.20.3":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.20.3.tar.gz"
+    sha256: "c6502c7aae641b7e20fafa6c2b92273d935d2b7b2707135ebd9a67b092169dca"
+  "8.8.1":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v8.8.1.tar.gz"
+    sha256: "056c7e21ad8ae36b026ac3b94b9d6e0fcc60e1d937fc80330921e4181be5c36e"
+patches:
+  "6.29.5":
+    - patch_file: "patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch"
+      patch_description: "Fix build with gcc 13 by including cstdint"
+      patch_type: "portability"
+      patch_source: "https://github.com/facebook/rocksdb/pull/11118"
+    - patch_file: "patches/6.29.5-0002-exclude-thirdparty.patch"
+      patch_description: "Do not include thirdparty.inc"
+      patch_type: "portability"
+  "6.27.3":
+    - patch_file: "patches/6.27.3-0001-add-include-cstdint-for-gcc-13.patch"
+      patch_description: "Fix build with gcc 13 by including cstdint"
+      patch_type: "portability"
+      patch_source: "https://github.com/facebook/rocksdb/pull/11118"

external/rocksdb/conanfile.py

@@ -0,0 +1,233 @@
+import os
+import glob
+import shutil
+
+from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.build import check_min_cppstd
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.files import apply_conandata_patches, collect_libs, copy, export_conandata_patches, get, rm, rmdir
+from conan.tools.microsoft import check_min_vs, is_msvc, is_msvc_static_runtime
+from conan.tools.scm import Version
+
+required_conan_version = ">=1.53.0"
+
+
+class RocksDBConan(ConanFile):
+    name = "rocksdb"
+    homepage = "https://github.com/facebook/rocksdb"
+    license = ("GPL-2.0-only", "Apache-2.0")
+    url = "https://github.com/conan-io/conan-center-index"
+    description = "A library that provides an embeddable, persistent key-value store for fast storage"
+    topics = ("database", "leveldb", "facebook", "key-value")
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "lite": [True, False],
+        "with_gflags": [True, False],
+        "with_snappy": [True, False],
+        "with_lz4": [True, False],
+        "with_zlib": [True, False],
+        "with_zstd": [True, False],
+        "with_tbb": [True, False],
+        "with_jemalloc": [True, False],
+        "enable_sse": [False, "sse42", "avx2"],
+        "use_rtti": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "lite": False,
+        "with_snappy": False,
+        "with_lz4": False,
+        "with_zlib": False,
+        "with_zstd": False,
+        "with_gflags": False,
+        "with_tbb": False,
+        "with_jemalloc": False,
+        "enable_sse": False,
+        "use_rtti": False,
+    }
+
+    @property
+    def _min_cppstd(self):
+        return "11" if Version(self.version) < "8.8.1" else "17"
+
+    @property
+    def _compilers_minimum_version(self):
+        return {} if self._min_cppstd == "11" else {
+                "apple-clang": "10",
+                "clang": "7",
+                "gcc": "7",
+                "msvc": "191",
+                "Visual Studio": "15",
+            }
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+        if self.settings.arch != "x86_64":
+            del self.options.with_tbb
+        if self.settings.build_type == "Debug":
+            self.options.use_rtti = True  # Rtti are used in asserts for debug mode...
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def requirements(self):
+        if self.options.with_gflags:
+            self.requires("gflags/2.2.2")
+        if self.options.with_snappy:
+            self.requires("snappy/1.1.10")
+        if self.options.with_lz4:
+            self.requires("lz4/1.10.0")
+        if self.options.with_zlib:
+            self.requires("zlib/[>=1.2.11 <2]")
+        if self.options.with_zstd:
+            self.requires("zstd/1.5.6")
+        if self.options.get_safe("with_tbb"):
+            self.requires("onetbb/2021.12.0")
+        if self.options.with_jemalloc:
+            self.requires("jemalloc/5.3.0")
+
+    def validate(self):
+        if self.settings.compiler.get_safe("cppstd"):
+            check_min_cppstd(self, self._min_cppstd)
+
+        minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
+        if minimum_version and Version(self.settings.compiler.version) < minimum_version:
+            raise ConanInvalidConfiguration(
+                f"{self.ref} requires C++{self._min_cppstd}, which your compiler does not support."
+            )
+
+        if self.settings.arch not in ["x86_64", "ppc64le", "ppc64", "mips64", "armv8"]:
+            raise ConanInvalidConfiguration("Rocksdb requires 64 bits")
+
+        check_min_vs(self, "191")
+
+        if self.version == "6.20.3" and \
+           self.settings.os == "Linux" and \
+           self.settings.compiler == "gcc" and \
+           Version(self.settings.compiler.version) < "5":
+            raise ConanInvalidConfiguration("Rocksdb 6.20.3 is not compilable with gcc <5.") # See https://github.com/facebook/rocksdb/issues/3522
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["FAIL_ON_WARNINGS"] = False
+        tc.variables["WITH_TESTS"] = False
+        tc.variables["WITH_TOOLS"] = False
+        tc.variables["WITH_CORE_TOOLS"] = False
+        tc.variables["WITH_BENCHMARK_TOOLS"] = False
+        tc.variables["WITH_FOLLY_DISTRIBUTED_MUTEX"] = False
+        if is_msvc(self):
+            tc.variables["WITH_MD_LIBRARY"] = not is_msvc_static_runtime(self)
+        tc.variables["ROCKSDB_INSTALL_ON_WINDOWS"] = self.settings.os == "Windows"
+        tc.variables["ROCKSDB_LITE"] = self.options.lite
+        tc.variables["WITH_GFLAGS"] = self.options.with_gflags
+        tc.variables["WITH_SNAPPY"] = self.options.with_snappy
+        tc.variables["WITH_LZ4"] = self.options.with_lz4
+        tc.variables["WITH_ZLIB"] = self.options.with_zlib
+        tc.variables["WITH_ZSTD"] = self.options.with_zstd
+        tc.variables["WITH_TBB"] = self.options.get_safe("with_tbb", False)
+        tc.variables["WITH_JEMALLOC"] = self.options.with_jemalloc
+        tc.variables["ROCKSDB_BUILD_SHARED"] = self.options.shared
+        tc.variables["ROCKSDB_LIBRARY_EXPORTS"] = self.settings.os == "Windows" and self.options.shared
+        tc.variables["ROCKSDB_DLL" ] = self.settings.os == "Windows" and self.options.shared
+        tc.variables["USE_RTTI"] = self.options.use_rtti
+        if not bool(self.options.enable_sse):
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = False
+        elif self.options.enable_sse == "sse42":
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = True
+        elif self.options.enable_sse == "avx2":
+            tc.variables["PORTABLE"] = False
+            tc.variables["FORCE_SSE42"] = False
+        # not available yet in CCI
+        tc.variables["WITH_NUMA"] = False
+        tc.generate()
+
+        deps = CMakeDeps(self)
+        if self.options.with_jemalloc:
+            deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
+            deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
+        deps.generate()
+
+    def build(self):
+        apply_conandata_patches(self)
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def _remove_static_libraries(self):
+        rm(self, "rocksdb.lib", os.path.join(self.package_folder, "lib"))
+        for lib in glob.glob(os.path.join(self.package_folder, "lib", "*.a")):
+            if not lib.endswith(".dll.a"):
+                os.remove(lib)
+
+    def _remove_cpp_headers(self):
+        for path in glob.glob(os.path.join(self.package_folder, "include", "rocksdb", "*")):
+            if path != os.path.join(self.package_folder, "include", "rocksdb", "c.h"):
+                if os.path.isfile(path):
+                    os.remove(path)
+                else:
+                    shutil.rmtree(path)
+
+    def package(self):
+        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        copy(self, "LICENSE*", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        cmake = CMake(self)
+        cmake.install()
+        if self.options.shared:
+            self._remove_static_libraries()
+            self._remove_cpp_headers() # Force stable ABI for shared libraries
+        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
+        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+
+    def package_info(self):
+        cmake_target = "rocksdb-shared" if self.options.shared else "rocksdb"
+        self.cpp_info.set_property("cmake_file_name", "RocksDB")
+        self.cpp_info.set_property("cmake_target_name", f"RocksDB::{cmake_target}")
+        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.components["librocksdb"].libs = collect_libs(self)
+        if self.settings.os == "Windows":
+            self.cpp_info.components["librocksdb"].system_libs = ["shlwapi", "rpcrt4"]
+            if self.options.shared:
+                self.cpp_info.components["librocksdb"].defines = ["ROCKSDB_DLL"]
+        elif self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.components["librocksdb"].system_libs = ["pthread", "m"]
+        if self.options.lite:
+            self.cpp_info.components["librocksdb"].defines.append("ROCKSDB_LITE")
+
+        # TODO: to remove in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.names["cmake_find_package"] = "RocksDB"
+        self.cpp_info.names["cmake_find_package_multi"] = "RocksDB"
+        self.cpp_info.components["librocksdb"].names["cmake_find_package"] = cmake_target
+        self.cpp_info.components["librocksdb"].names["cmake_find_package_multi"] = cmake_target
+        self.cpp_info.components["librocksdb"].set_property("cmake_target_name", f"RocksDB::{cmake_target}")
+        if self.options.with_gflags:
+            self.cpp_info.components["librocksdb"].requires.append("gflags::gflags")
+        if self.options.with_snappy:
+            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_lz4:
+            self.cpp_info.components["librocksdb"].requires.append("lz4::lz4")
+        if self.options.with_zlib:
+            self.cpp_info.components["librocksdb"].requires.append("zlib::zlib")
+        if self.options.with_zstd:
+            self.cpp_info.components["librocksdb"].requires.append("zstd::zstd")
+        if self.options.get_safe("with_tbb"):
+            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
+        if self.options.with_jemalloc:
+            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")

external/rocksdb/patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch

@@ -0,0 +1,30 @@
+--- a/include/rocksdb/utilities/checkpoint.h
++++ b/include/rocksdb/utilities/checkpoint.h
+@@ -8,6 +8,7 @@
+ #pragma once
+ #ifndef ROCKSDB_LITE
+ 
++#include <cstdint>
+ #include <string>
+ #include <vector>
+ #include "rocksdb/status.h"
+--- a/table/block_based/data_block_hash_index.h
++++ b/table/block_based/data_block_hash_index.h
+@@ -5,6 +5,7 @@
+ 
+ #pragma once
+ 
++#include <cstdint>
+ #include <string>
+ #include <vector>
+ 
+--- a/util/string_util.h
++++ b/util/string_util.h
+@@ -6,6 +6,7 @@
+ 
+ #pragma once
+ 
++#include <cstdint>
+ #include <sstream>
+ #include <string>
+ #include <unordered_map>

external/rocksdb/patches/6.29.5-0002-exclude-thirdparty.patch

@@ -0,0 +1,16 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index ec59d4491..35577c998 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -101 +100,0 @@ if(MSVC)
+-  option(WITH_GFLAGS "build with GFlags" OFF)
+@@ -103,2 +102,2 @@ if(MSVC)
+-  include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
+-else()
++endif()
++
+@@ -117 +116 @@ else()
+-  if(MINGW)
++  if(MINGW OR MSVC)
+@@ -183 +181,0 @@ else()
+-endif()

hook/error.h

@@ -47,5 +47,8 @@
 #define MEM_OVERLAP -43
 #define TOO_MANY_STATE_MODIFICATIONS -44
 #define TOO_MANY_NAMESPACES -45
+#define EXPORT_FAILURE -46
+#define TOO_MANY_EXPORTED_TXN -47
+#define TOO_LITTLE_ENTROPY -48
 #define HOOK_ERROR_CODES
 #endif //HOOK_ERROR_CODES

hook/extern.h

@@ -336,5 +336,24 @@ prepare(
     uint32_t read_ptr,
     uint32_t read_len);
 
+extern int64_t
+xport_reserve(uint32_t count);
+
+extern int64_t
+xport(
+    uint32_t write_ptr,
+    uint32_t write_len,
+    uint32_t read_ptr,
+    uint32_t read_len);
+
+extern int64_t
+xport_cancel(uint32_t ticket_seq);
+
+extern int64_t
+dice(uint32_t sides);
+
+extern int64_t
+random(uint32_t write_ptr, uint32_t write_len);
+
 #define HOOK_EXTERN
 #endif  // HOOK_EXTERN

hook/hookapi.h

@@ -45,8 +45,8 @@
 
 #include "error.h"
 #include "extern.h"
-#include "macro.h"
 #include "sfcodes.h"
+#include "macro.h"
 #include "tts.h"
 
 #endif

hook/sfcodes.h

@@ -9,7 +9,7 @@
 #define sfUNLModifyDisabling ((16U << 16U) + 17U)
 #define sfHookResult ((16U << 16U) + 18U)
 #define sfWasLockingChainSend ((16U << 16U) + 19U)
-#define sfWithdrawalPolicy ((16U << 16U) + 20U)
+#define sfSidecarType ((16U << 16U) + 20U)
 #define sfLedgerEntryType ((1U << 16U) + 1U)
 #define sfTransactionType ((1U << 16U) + 2U)
 #define sfSignerWeight ((1U << 16U) + 3U)
@@ -23,6 +23,8 @@
 #define sfHookApiVersion ((1U << 16U) + 20U)
 #define sfHookStateScale ((1U << 16U) + 21U)
 #define sfLedgerFixType ((1U << 16U) + 22U)
+#define sfHookExportCount ((1U << 16U) + 98U)
+#define sfEntropyCount ((1U << 16U) + 99U)
 #define sfNetworkID ((2U << 16U) + 1U)
 #define sfFlags ((2U << 16U) + 2U)
 #define sfSourceTag ((2U << 16U) + 3U)
@@ -73,7 +75,6 @@
 #define sfLockCount ((2U << 16U) + 49U)
 #define sfFirstNFTokenSequence ((2U << 16U) + 50U)
 #define sfOracleDocumentID ((2U << 16U) + 51U)
-#define sfPermissionValue ((2U << 16U) + 52U)
 #define sfStartTime ((2U << 16U) + 93U)
 #define sfRepeatCount ((2U << 16U) + 94U)
 #define sfDelaySeconds ((2U << 16U) + 95U)
@@ -82,6 +83,7 @@
 #define sfRewardTime ((2U << 16U) + 98U)
 #define sfRewardLgrFirst ((2U << 16U) + 99U)
 #define sfRewardLgrLast ((2U << 16U) + 100U)
+#define sfCancelTicketSequence ((2U << 16U) + 101U)
 #define sfIndexNext ((3U << 16U) + 1U)
 #define sfIndexPrevious ((3U << 16U) + 2U)
 #define sfBookNode ((3U << 16U) + 3U)
@@ -117,7 +119,6 @@
 #define sfTakerGetsCurrency ((17U << 16U) + 3U)
 #define sfTakerGetsIssuer ((17U << 16U) + 4U)
 #define sfMPTokenIssuanceID ((21U << 16U) + 1U)
-#define sfShareMPTID ((21U << 16U) + 2U)
 #define sfLedgerHash ((5U << 16U) + 1U)
 #define sfParentHash ((5U << 16U) + 2U)
 #define sfTransactionHash ((5U << 16U) + 3U)
@@ -155,8 +156,6 @@
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
 #define sfDomainID ((5U << 16U) + 37U)
-#define sfVaultID ((5U << 16U) + 38U)
-#define sfParentBatchID ((5U << 16U) + 39U)
 #define sfHookOnOutgoing ((5U << 16U) + 93U)
 #define sfHookOnIncoming ((5U << 16U) + 94U)
 #define sfCron ((5U << 16U) + 95U)
@@ -164,11 +163,8 @@
 #define sfEmittedTxnID ((5U << 16U) + 97U)
 #define sfGovernanceMarks ((5U << 16U) + 98U)
 #define sfGovernanceFlags ((5U << 16U) + 99U)
+#define sfEntropyDigest ((5U << 16U) + 100U)
 #define sfNumber ((9U << 16U) + 1U)
-#define sfAssetsAvailable ((9U << 16U) + 2U)
-#define sfAssetsMaximum ((9U << 16U) + 3U)
-#define sfAssetsTotal ((9U << 16U) + 4U)
-#define sfLossUnrealized ((9U << 16U) + 5U)
 #define sfAmount ((6U << 16U) + 1U)
 #define sfBalance ((6U << 16U) + 2U)
 #define sfLimitAmount ((6U << 16U) + 3U)
@@ -241,7 +237,6 @@
 #define sfNFTokenMinter ((8U << 16U) + 9U)
 #define sfEmitCallback ((8U << 16U) + 10U)
 #define sfHolder ((8U << 16U) + 11U)
-#define sfDelegate ((8U << 16U) + 12U)
 #define sfHookAccount ((8U << 16U) + 16U)
 #define sfOtherChainSource ((8U << 16U) + 18U)
 #define sfOtherChainDestination ((8U << 16U) + 19U)
@@ -279,7 +274,6 @@
 #define sfNFToken ((14U << 16U) + 12U)
 #define sfEmitDetails ((14U << 16U) + 13U)
 #define sfHook ((14U << 16U) + 14U)
-#define sfPermission ((14U << 16U) + 15U)
 #define sfSigner ((14U << 16U) + 16U)
 #define sfMajority ((14U << 16U) + 18U)
 #define sfDisabledValidator ((14U << 16U) + 19U)
@@ -297,9 +291,7 @@
 #define sfXChainCreateAccountAttestationCollectionElement ((14U << 16U) + 31U)
 #define sfPriceData ((14U << 16U) + 32U)
 #define sfCredential ((14U << 16U) + 33U)
-#define sfRawTransaction ((14U << 16U) + 34U)
-#define sfBatchSigner ((14U << 16U) + 35U)
-#define sfBook ((14U << 16U) + 36U)
+#define sfExportedTxn ((14U << 16U) + 90U)
 #define sfAmountEntry ((14U << 16U) + 91U)
 #define sfMintURIToken ((14U << 16U) + 92U)
 #define sfHookEmission ((14U << 16U) + 93U)
@@ -307,6 +299,7 @@
 #define sfActiveValidator ((14U << 16U) + 95U)
 #define sfGenesisMint ((14U << 16U) + 96U)
 #define sfRemark ((14U << 16U) + 97U)
+#define sfExportResult ((14U << 16U) + 98U)
 #define sfSigners ((15U << 16U) + 3U)
 #define sfSignerEntries ((15U << 16U) + 4U)
 #define sfTemplate ((15U << 16U) + 5U)
@@ -317,7 +310,6 @@
 #define sfNFTokens ((15U << 16U) + 10U)
 #define sfHooks ((15U << 16U) + 11U)
 #define sfVoteSlots ((15U << 16U) + 12U)
-#define sfAdditionalBooks ((15U << 16U) + 13U)
 #define sfMajorities ((15U << 16U) + 16U)
 #define sfDisabledValidators ((15U << 16U) + 17U)
 #define sfHookExecutions ((15U << 16U) + 18U)
@@ -330,9 +322,6 @@
 #define sfAuthorizeCredentials ((15U << 16U) + 26U)
 #define sfUnauthorizeCredentials ((15U << 16U) + 27U)
 #define sfAcceptedCredentials ((15U << 16U) + 28U)
-#define sfPermissions ((15U << 16U) + 29U)
-#define sfRawTransactions ((15U << 16U) + 30U)
-#define sfBatchSigners ((15U << 16U) + 31U)
 #define sfAmounts ((15U << 16U) + 92U)
 #define sfHookEmissions ((15U << 16U) + 93U)
 #define sfImportVLKeys ((15U << 16U) + 94U)

hook/tts.h

@@ -61,14 +61,7 @@
 #define ttNFTOKEN_MODIFY 70
 #define ttPERMISSIONED_DOMAIN_SET 71
 #define ttPERMISSIONED_DOMAIN_DELETE 72
-#define ttDELEGATE_SET 73
-#define ttVAULT_CREATE 74
-#define ttVAULT_SET 75
-#define ttVAULT_DELETE 76
-#define ttVAULT_DEPOSIT 77
-#define ttVAULT_WITHDRAW 78
-#define ttVAULT_CLAWBACK 79
-#define ttBATCH 80
+#define ttEXPORT 91
 #define ttCRON 92
 #define ttCRON_SET 93
 #define ttREMARKS_SET 94
@@ -82,3 +75,4 @@
 #define ttUNL_MODIFY 102
 #define ttEMIT_FAILURE 103
 #define ttUNL_REPORT 104
+#define ttCONSENSUS_ENTROPY 105

include/xrpl/basics/BasicConfig.h

@@ -27,6 +27,7 @@
 
 #include <algorithm>
 #include <optional>
+#include <ostream>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -367,7 +368,7 @@ get(Section const& section,
 }
 
 inline std::string
-get(Section const& section, std::string const& name, char const* defaultValue)
+get(Section const& section, std::string const& name, const char* defaultValue)
 {
     try
     {

include/xrpl/basics/Buffer.h

@@ -22,10 +22,10 @@
 
 #include <xrpl/basics/Slice.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <cstdint>
 #include <cstring>
 #include <memory>
+#include <utility>
 
 namespace ripple {
 

include/xrpl/basics/CompressionAlgorithms.h

@@ -21,11 +21,9 @@
 #define RIPPLED_COMPRESSIONALGORITHMS_H_INCLUDED
 
 #include <xrpl/basics/contract.h>
-
-#include <lz4.h>
-
 #include <algorithm>
 #include <cstdint>
+#include <lz4.h>
 #include <stdexcept>
 #include <vector>
 
@@ -55,7 +53,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     auto compressed = bf(outCapacity);
 
     auto compressedSize = LZ4_compress_default(
-        reinterpret_cast<char const*>(in),
+        reinterpret_cast<const char*>(in),
         reinterpret_cast<char*>(compressed),
         inSize,
         outCapacity);
@@ -89,7 +87,7 @@ lz4Decompress(
         Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
 
     if (LZ4_decompress_safe(
-            reinterpret_cast<char const*>(in),
+            reinterpret_cast<const char*>(in),
             reinterpret_cast<char*>(decompressed),
             inSize,
             decompressedSize) != decompressedSize)

include/xrpl/basics/CountedObject.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_COUNTEDOBJECT_H_INCLUDED
 
 #include <xrpl/beast/type_name.h>
-
 #include <atomic>
 #include <string>
 #include <utility>

include/xrpl/basics/Expected.h

@@ -22,19 +22,11 @@
 
 #include <xrpl/basics/contract.h>
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 #include <boost/outcome.hpp>
 
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
+#include <concepts>
 #include <stdexcept>
+#include <type_traits>
 
 namespace ripple {
 
@@ -103,7 +95,7 @@ public:
     {
     }
 
-    constexpr E const&
+    constexpr const E&
     value() const&
     {
         return val_;
@@ -121,7 +113,7 @@ public:
         return std::move(val_);
     }
 
-    constexpr E const&&
+    constexpr const E&&
     value() const&&
     {
         return std::move(val_);

include/xrpl/basics/IntrusivePointer.h

@@ -1,515 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEPOINTER_H_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEPOINTER_H_INCLUDED
-
-#include <concepts>
-#include <cstdint>
-#include <type_traits>
-#include <utility>
-
-namespace ripple {
-
-//------------------------------------------------------------------------------
-
-/** Tag to create an intrusive pointer from another intrusive pointer by using a
-    static cast. This is useful to create an intrusive pointer to a derived
-    class from an intrusive pointer to a base class.
-*/
-struct StaticCastTagSharedIntrusive
-{
-};
-
-/** Tag to create an intrusive pointer from another intrusive pointer by using a
-    dynamic cast. This is useful to create an intrusive pointer to a derived
-    class from an intrusive pointer to a base class. If the cast fails an empty
-    (null) intrusive pointer is created.
-*/
-struct DynamicCastTagSharedIntrusive
-{
-};
-
-/** When creating or adopting a raw pointer, controls whether the strong count
-    is incremented or not. Use this tag to increment the strong count.
-*/
-struct SharedIntrusiveAdoptIncrementStrongTag
-{
-};
-
-/** When creating or adopting a raw pointer, controls whether the strong count
-    is incremented or not. Use this tag to leave the strong count unchanged.
-*/
-struct SharedIntrusiveAdoptNoIncrementTag
-{
-};
-
-//------------------------------------------------------------------------------
-//
-
-template <class T>
-concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
-    std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
-
-//------------------------------------------------------------------------------
-
-/** A shared intrusive pointer class that supports weak pointers.
-
-    This is meant to be used for SHAMapInnerNodes, but may be useful for other
-    cases. Since the reference counts are stored on the pointee, the pointee is
-    not destroyed until both the strong _and_ weak pointer counts go to zero.
-    When the strong pointer count goes to zero, the "partialDestructor" is
-    called. This can be used to destroy as much of the object as possible while
-    still retaining the reference counts. For example, for SHAMapInnerNodes the
-    children may be reset in that function. Note that std::shared_poiner WILL
-    run the destructor when the strong count reaches zero, but may not free the
-    memory used by the object until the weak count reaches zero. In rippled, we
-    typically allocate shared pointers with the `make_shared` function. When
-    that is used, the memory is not reclaimed until the weak count reaches zero.
-*/
-template <class T>
-class SharedIntrusive
-{
-public:
-    SharedIntrusive() = default;
-
-    template <CAdoptTag TAdoptTag>
-    SharedIntrusive(T* p, TAdoptTag) noexcept;
-
-    SharedIntrusive(SharedIntrusive const& rhs);
-
-    template <class TT>
-    // TODO: convertible_to isn't quite right. That include a static castable.
-    // Find the right concept.
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive(SharedIntrusive<TT> const& rhs);
-
-    SharedIntrusive(SharedIntrusive&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive(SharedIntrusive<TT>&& rhs);
-
-    SharedIntrusive&
-    operator=(SharedIntrusive const& rhs);
-
-    bool
-    operator!=(std::nullptr_t) const;
-
-    bool
-    operator==(std::nullptr_t) const;
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    SharedIntrusive&
-    operator=(SharedIntrusive&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive&
-    operator=(SharedIntrusive<TT>&& rhs);
-
-    /** Adopt the raw pointer. The strong reference may or may not be
-        incremented, depending on the TAdoptTag
-     */
-    template <CAdoptTag TAdoptTag = SharedIntrusiveAdoptIncrementStrongTag>
-    void
-    adopt(T* p);
-
-    ~SharedIntrusive();
-
-    /** Create a new SharedIntrusive by statically casting the pointer
-        controlled by the rhs param.
-    */
-    template <class TT>
-    SharedIntrusive(
-        StaticCastTagSharedIntrusive,
-        SharedIntrusive<TT> const& rhs);
-
-    /** Create a new SharedIntrusive by statically casting the pointer
-       controlled by the rhs param.
-    */
-    template <class TT>
-    SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
-
-    /** Create a new SharedIntrusive by dynamically casting the pointer
-       controlled by the rhs param.
-    */
-    template <class TT>
-    SharedIntrusive(
-        DynamicCastTagSharedIntrusive,
-        SharedIntrusive<TT> const& rhs);
-
-    /** Create a new SharedIntrusive by dynamically casting the pointer
-       controlled by the rhs param.
-    */
-    template <class TT>
-    SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
-
-    T&
-    operator*() const noexcept;
-
-    T*
-    operator->() const noexcept;
-
-    explicit
-    operator bool() const noexcept;
-
-    /** Set the pointer to null, decrement the strong count, and run the
-        appropriate release action.
-      */
-    void
-    reset();
-
-    /** Get the raw pointer */
-    T*
-    get() const;
-
-    /** Return the strong count */
-    std::size_t
-    use_count() const;
-
-    template <class TT, class... Args>
-    friend SharedIntrusive<TT>
-    make_SharedIntrusive(Args&&... args);
-
-    template <class TT>
-    friend class SharedIntrusive;
-
-    template <class TT>
-    friend class SharedWeakUnion;
-
-    template <class TT>
-    friend class WeakIntrusive;
-
-private:
-    /** Return the raw pointer held by this object. */
-    T*
-    unsafeGetRawPtr() const;
-
-    /** Exchange the current raw pointer held by this object with the given
-        pointer. Decrement the strong count of the raw pointer previously held
-        by this object and run the appropriate release action.
-     */
-    void
-    unsafeReleaseAndStore(T* next);
-
-    /** Set the raw pointer directly. This is wrapped in a function so the class
-        can support both atomic and non-atomic pointers in a future patch.
-     */
-    void
-    unsafeSetRawPtr(T* p);
-
-    /** Exchange the raw pointer directly.
-        This sets the raw pointer to the given value and returns the previous
-        value. This is wrapped in a function so the class can support both
-        atomic and non-atomic pointers in a future patch.
-     */
-    T*
-    unsafeExchange(T* p);
-
-    /** pointer to the type with an intrusive count */
-    T* ptr_{nullptr};
-};
-
-//------------------------------------------------------------------------------
-
-/** A weak intrusive pointer class for the SharedIntrusive pointer class.
-
-Note that this weak pointer class asks differently from normal weak pointer
-classes. When the strong pointer count goes to zero, the "partialDestructor"
-is called. See the comment on SharedIntrusive for a fuller explanation.
-*/
-template <class T>
-class WeakIntrusive
-{
-public:
-    WeakIntrusive() = default;
-
-    WeakIntrusive(WeakIntrusive const& rhs);
-
-    WeakIntrusive(WeakIntrusive&& rhs);
-
-    WeakIntrusive(SharedIntrusive<T> const& rhs);
-
-    // There is no move constructor from a strong intrusive ptr because
-    // moving would be move expensive than copying in this case (the strong
-    // ref would need to be decremented)
-    WeakIntrusive(SharedIntrusive<T> const&& rhs) = delete;
-
-    // Since there are no current use cases for copy assignment in
-    // WeakIntrusive, we delete this operator to simplify the implementation. If
-    // a need arises in the future, we can reintroduce it with proper
-    // consideration."
-    WeakIntrusive&
-    operator=(WeakIntrusive const&) = delete;
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    WeakIntrusive&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    /** Adopt the raw pointer and increment the weak count. */
-    void
-    adopt(T* ptr);
-
-    ~WeakIntrusive();
-
-    /** Get a strong pointer from the weak pointer, if possible. This will
-       only return a seated pointer if the strong count on the raw pointer
-       is non-zero before locking.
-     */
-    SharedIntrusive<T>
-    lock() const;
-
-    /** Return true if the strong count is zero. */
-    bool
-    expired() const;
-
-    /** Set the pointer to null and decrement the weak count.
-
-    Note: This may run the destructor if the strong count is zero.
-    */
-    void
-    reset();
-
-private:
-    T* ptr_ = nullptr;
-
-    /** Decrement the weak count. This does _not_ set the raw pointer to
-    null.
-
-    Note: This may run the destructor if the strong count is zero.
-    */
-    void
-    unsafeReleaseNoStore();
-};
-
-//------------------------------------------------------------------------------
-
-/** A combination of a strong and a weak intrusive pointer stored in the
-    space of a single pointer.
-
-    This class is similar to a `std::variant<SharedIntrusive,WeakIntrusive>`
-    with some optimizations. In particular, it uses a low-order bit to
-    determine if the raw pointer represents a strong pointer or a weak
-    pointer. It can also be quickly switched between its strong pointer and
-    weak pointer representations. This class is useful for storing intrusive
-    pointers in tagged caches.
-  */
-
-template <class T>
-class SharedWeakUnion
-{
-    // Tagged pointer. Low bit determines if this is a strong or a weak
-    // 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.
-    static_assert(
-        alignof(T) >= 2,
-        "Bad alignment: Combo pointer requires low bit to be zero");
-
-public:
-    SharedWeakUnion() = default;
-
-    SharedWeakUnion(SharedWeakUnion const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion(SharedIntrusive<TT> const& rhs);
-
-    SharedWeakUnion(SharedWeakUnion&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion(SharedIntrusive<TT>&& rhs);
-
-    SharedWeakUnion&
-    operator=(SharedWeakUnion const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion&
-    operator=(SharedIntrusive<TT>&& rhs);
-
-    ~SharedWeakUnion();
-
-    /** Return a strong pointer if this is already a strong pointer (i.e.
-       don't lock the weak pointer. Use the `lock` method if that's what's
-       needed)
-     */
-    SharedIntrusive<T>
-    getStrong() const;
-
-    /** Return true if this is a strong pointer and the strong pointer is
-        seated.
-     */
-    explicit
-    operator bool() const noexcept;
-
-    /** Set the pointer to null, decrement the appropriate ref count, and
-       run the appropriate release action.
-     */
-    void
-    reset();
-
-    /** If this is a strong pointer, return the raw pointer. Otherwise
-       return null.
-     */
-    T*
-    get() const;
-
-    /** If this is a strong pointer, return the strong count. Otherwise
-     * return 0
-     */
-    std::size_t
-    use_count() const;
-
-    /** Return true if there is a non-zero strong count. */
-    bool
-    expired() const;
-
-    /** If this is a strong pointer, return the strong pointer. Otherwise
-        attempt to lock the weak pointer.
-     */
-    SharedIntrusive<T>
-    lock() const;
-
-    /** Return true is this represents a strong pointer. */
-    bool
-    isStrong() const;
-
-    /** Return true is this represents a weak pointer. */
-    bool
-    isWeak() const;
-
-    /** If this is a weak pointer, attempt to convert it to a strong
-       pointer.
-
-        @return true if successfully converted to a strong pointer (or was
-                already a strong pointer). Otherwise false.
-      */
-    bool
-    convertToStrong();
-
-    /** If this is a strong pointer, attempt to convert it to a weak
-       pointer.
-
-        @return false if the pointer is null. Otherwise return true.
-      */
-    bool
-    convertToWeak();
-
-private:
-    // Tagged pointer. Low bit determines if this is a strong or a weak
-    // 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 tagMask = 1;
-    static constexpr std::uintptr_t ptrMask = ~tagMask;
-
-private:
-    /** Return the raw pointer held by this object.
-     */
-    T*
-    unsafeGetRawPtr() const;
-
-    enum class RefStrength { strong, weak };
-    /** Set the raw pointer and tag bit directly.
-     */
-    void
-    unsafeSetRawPtr(T* p, RefStrength rs);
-
-    /** Set the raw pointer and tag bit to all zeros (strong null pointer).
-     */
-    void unsafeSetRawPtr(std::nullptr_t);
-
-    /** Decrement the appropriate ref count, and run the appropriate release
-        action. Note: this does _not_ set the raw pointer to null.
-     */
-    void
-    unsafeReleaseNoStore();
-};
-
-//------------------------------------------------------------------------------
-
-/** Create a shared intrusive pointer.
-
-    Note: unlike std::shared_ptr, where there is an advantage of allocating
-    the pointer and control block together, there is no benefit for intrusive
-    pointers.
-*/
-template <class TT, class... Args>
-SharedIntrusive<TT>
-make_SharedIntrusive(Args&&... args)
-{
-    auto p = new TT(std::forward<Args>(args)...);
-
-    static_assert(
-        noexcept(SharedIntrusive<TT>(
-            std::declval<TT*>(),
-            std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
-        "SharedIntrusive constructor should not throw or this can leak "
-        "memory");
-
-    return SharedIntrusive<TT>(p, SharedIntrusiveAdoptNoIncrementTag{});
-}
-
-//------------------------------------------------------------------------------
-
-namespace intr_ptr {
-template <class T>
-using SharedPtr = SharedIntrusive<T>;
-
-template <class T>
-using WeakPtr = WeakIntrusive<T>;
-
-template <class T>
-using SharedWeakUnionPtr = SharedWeakUnion<T>;
-
-template <class T, class... A>
-SharedPtr<T>
-make_shared(A&&... args)
-{
-    return make_SharedIntrusive<T>(std::forward<A>(args)...);
-}
-
-template <class T, class TT>
-SharedPtr<T>
-static_pointer_cast(TT const& v)
-{
-    return SharedPtr<T>(StaticCastTagSharedIntrusive{}, v);
-}
-
-template <class T, class TT>
-SharedPtr<T>
-dynamic_pointer_cast(TT const& v)
-{
-    return SharedPtr<T>(DynamicCastTagSharedIntrusive{}, v);
-}
-}  // namespace intr_ptr
-}  // namespace ripple
-#endif

include/xrpl/basics/IntrusivePointer.ipp

@@ -1,740 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEPOINTER_IPP_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEPOINTER_IPP_INCLUDED
-
-#include <xrpl/basics/IntrusivePointer.h>
-#include <xrpl/basics/IntrusiveRefCounts.h>
-
-#include <utility>
-
-namespace ripple {
-
-template <class T>
-template <CAdoptTag TAdoptTag>
-SharedIntrusive<T>::SharedIntrusive(T* p, TAdoptTag) noexcept : ptr_{p}
-{
-    if constexpr (std::is_same_v<
-                      TAdoptTag,
-                      SharedIntrusiveAdoptIncrementStrongTag>)
-    {
-        if (p)
-            p->addStrongRef();
-    }
-}
-
-template <class T>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive const& rhs)
-    : ptr_{[&] {
-        auto p = rhs.unsafeGetRawPtr();
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = rhs.unsafeGetRawPtr();
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive&& rhs)
-    : ptr_{rhs.unsafeExchange(nullptr)}
-{
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT>&& rhs)
-    : ptr_{rhs.unsafeExchange(nullptr)}
-{
-}
-template <class T>
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive const& rhs)
-{
-    if (this == &rhs)
-        return *this;
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeReleaseAndStore(p);
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    if constexpr (std::is_same_v<T, TT>)
-    {
-        // This case should never be hit. The operator above will run instead.
-        // (The normal operator= is needed or it will be marked `deleted`)
-        if (this == &rhs)
-            return *this;
-    }
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeReleaseAndStore(p);
-    return *this;
-}
-
-template <class T>
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive&& rhs)
-{
-    if (this == &rhs)
-        return *this;
-
-    unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive<TT>&& rhs)
-{
-    static_assert(
-        !std::is_same_v<T, TT>,
-        "This overload should not be instantiated for T == TT");
-
-    unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
-    return *this;
-}
-
-template <class T>
-bool
-SharedIntrusive<T>::operator!=(std::nullptr_t) const
-{
-    return this->get() != nullptr;
-}
-
-template <class T>
-bool
-SharedIntrusive<T>::operator==(std::nullptr_t) const
-{
-    return this->get() == nullptr;
-}
-
-template <class T>
-template <CAdoptTag TAdoptTag>
-void
-SharedIntrusive<T>::adopt(T* p)
-{
-    if constexpr (std::is_same_v<
-                      TAdoptTag,
-                      SharedIntrusiveAdoptIncrementStrongTag>)
-    {
-        if (p)
-            p->addStrongRef();
-    }
-    unsafeReleaseAndStore(p);
-}
-
-template <class T>
-SharedIntrusive<T>::~SharedIntrusive()
-{
-    unsafeReleaseAndStore(nullptr);
-};
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    StaticCastTagSharedIntrusive,
-    SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = static_cast<T*>(rhs.unsafeGetRawPtr());
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    StaticCastTagSharedIntrusive,
-    SharedIntrusive<TT>&& rhs)
-    : ptr_{static_cast<T*>(rhs.unsafeExchange(nullptr))}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    DynamicCastTagSharedIntrusive,
-    SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = dynamic_cast<T*>(rhs.unsafeGetRawPtr());
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    DynamicCastTagSharedIntrusive,
-    SharedIntrusive<TT>&& rhs)
-{
-    // This can be simplified without the `exchange`, but the `exchange` is kept
-    // in anticipation of supporting atomic operations.
-    auto toSet = rhs.unsafeExchange(nullptr);
-    if (toSet)
-    {
-        ptr_ = dynamic_cast<T*>(toSet);
-        if (!ptr_)
-            // need to set the pointer back or will leak
-            rhs.unsafeExchange(toSet);
-    }
-}
-
-template <class T>
-T&
-SharedIntrusive<T>::operator*() const noexcept
-{
-    return *unsafeGetRawPtr();
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::operator->() const noexcept
-{
-    return unsafeGetRawPtr();
-}
-
-template <class T>
-SharedIntrusive<T>::operator bool() const noexcept
-{
-    return bool(unsafeGetRawPtr());
-}
-
-template <class T>
-void
-SharedIntrusive<T>::reset()
-{
-    unsafeReleaseAndStore(nullptr);
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::get() const
-{
-    return unsafeGetRawPtr();
-}
-
-template <class T>
-std::size_t
-SharedIntrusive<T>::use_count() const
-{
-    if (auto p = unsafeGetRawPtr())
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::unsafeGetRawPtr() const
-{
-    return ptr_;
-}
-
-template <class T>
-void
-SharedIntrusive<T>::unsafeSetRawPtr(T* p)
-{
-    ptr_ = p;
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::unsafeExchange(T* p)
-{
-    return std::exchange(ptr_, p);
-}
-
-template <class T>
-void
-SharedIntrusive<T>::unsafeReleaseAndStore(T* next)
-{
-    auto prev = unsafeExchange(next);
-    if (!prev)
-        return;
-
-    using enum ReleaseStrongRefAction;
-    auto action = prev->releaseStrongRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            delete prev;
-            break;
-        case partialDestroy:
-            prev->partialDestructor();
-            partialDestructorFinished(&prev);
-            // prev is null and may no longer be used
-            break;
-    }
-}
-
-//------------------------------------------------------------------------------
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(WeakIntrusive const& rhs) : ptr_{rhs.ptr_}
-{
-    if (ptr_)
-        ptr_->addWeakRef();
-}
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(WeakIntrusive&& rhs) : ptr_{rhs.ptr_}
-{
-    rhs.ptr_ = nullptr;
-}
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(SharedIntrusive<T> const& rhs)
-    : ptr_{rhs.unsafeGetRawPtr()}
-{
-    if (ptr_)
-        ptr_->addWeakRef();
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-WeakIntrusive<T>&
-WeakIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    unsafeReleaseNoStore();
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addWeakRef();
-    return *this;
-}
-
-template <class T>
-void
-WeakIntrusive<T>::adopt(T* ptr)
-{
-    unsafeReleaseNoStore();
-    if (ptr)
-        ptr->addWeakRef();
-    ptr_ = ptr;
-}
-
-template <class T>
-WeakIntrusive<T>::~WeakIntrusive()
-{
-    unsafeReleaseNoStore();
-}
-
-template <class T>
-SharedIntrusive<T>
-WeakIntrusive<T>::lock() const
-{
-    if (ptr_ && ptr_->checkoutStrongRefFromWeak())
-    {
-        return SharedIntrusive<T>{ptr_, SharedIntrusiveAdoptNoIncrementTag{}};
-    }
-    return {};
-}
-
-template <class T>
-bool
-WeakIntrusive<T>::expired() const
-{
-    return (!ptr_ || ptr_->expired());
-}
-
-template <class T>
-void
-WeakIntrusive<T>::reset()
-{
-    unsafeReleaseNoStore();
-    ptr_ = nullptr;
-}
-
-template <class T>
-void
-WeakIntrusive<T>::unsafeReleaseNoStore()
-{
-    if (!ptr_)
-        return;
-
-    using enum ReleaseWeakRefAction;
-    auto action = ptr_->releaseWeakRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            delete ptr_;
-            break;
-    }
-}
-
-//------------------------------------------------------------------------------
-
-template <class T>
-SharedWeakUnion<T>::SharedWeakUnion(SharedWeakUnion const& rhs) : tp_{rhs.tp_}
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (!p)
-        return;
-
-    if (rhs.isStrong())
-        p->addStrongRef();
-    else
-        p->addWeakRef();
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakUnion<T>::SharedWeakUnion(SharedIntrusive<TT> const& rhs)
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeSetRawPtr(p, RefStrength::strong);
-}
-
-template <class T>
-SharedWeakUnion<T>::SharedWeakUnion(SharedWeakUnion&& rhs) : tp_{rhs.tp_}
-{
-    rhs.unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakUnion<T>::SharedWeakUnion(SharedIntrusive<TT>&& rhs)
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        unsafeSetRawPtr(p, RefStrength::strong);
-    rhs.unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedWeakUnion const& rhs)
-{
-    if (this == &rhs)
-        return *this;
-    unsafeReleaseNoStore();
-
-    if (auto p = rhs.unsafeGetRawPtr())
-    {
-        if (rhs.isStrong())
-        {
-            p->addStrongRef();
-            unsafeSetRawPtr(p, RefStrength::strong);
-        }
-        else
-        {
-            p->addWeakRef();
-            unsafeSetRawPtr(p, RefStrength::weak);
-        }
-    }
-    else
-    {
-        unsafeSetRawPtr(nullptr);
-    }
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    unsafeReleaseNoStore();
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeSetRawPtr(p, RefStrength::strong);
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedIntrusive<TT>&& rhs)
-{
-    unsafeReleaseNoStore();
-    unsafeSetRawPtr(rhs.unsafeGetRawPtr(), RefStrength::strong);
-    rhs.unsafeSetRawPtr(nullptr);
-    return *this;
-}
-
-template <class T>
-SharedWeakUnion<T>::~SharedWeakUnion()
-{
-    unsafeReleaseNoStore();
-};
-
-// Return a strong pointer if this is already a strong pointer (i.e. don't
-// lock the weak pointer. Use the `lock` method if that's what's needed)
-template <class T>
-SharedIntrusive<T>
-SharedWeakUnion<T>::getStrong() const
-{
-    SharedIntrusive<T> result;
-    auto p = unsafeGetRawPtr();
-    if (p && isStrong())
-    {
-        result.template adopt<SharedIntrusiveAdoptIncrementStrongTag>(p);
-    }
-    return result;
-}
-
-template <class T>
-SharedWeakUnion<T>::operator bool() const noexcept
-{
-    return bool(get());
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::reset()
-{
-    unsafeReleaseNoStore();
-    unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-T*
-SharedWeakUnion<T>::get() const
-{
-    return isStrong() ? unsafeGetRawPtr() : nullptr;
-}
-
-template <class T>
-std::size_t
-SharedWeakUnion<T>::use_count() const
-{
-    if (auto p = get())
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::expired() const
-{
-    auto p = unsafeGetRawPtr();
-    return (!p || p->expired());
-}
-
-template <class T>
-SharedIntrusive<T>
-SharedWeakUnion<T>::lock() const
-{
-    SharedIntrusive<T> result;
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return result;
-
-    if (isStrong())
-    {
-        result.template adopt<SharedIntrusiveAdoptIncrementStrongTag>(p);
-        return result;
-    }
-
-    if (p->checkoutStrongRefFromWeak())
-    {
-        result.template adopt<SharedIntrusiveAdoptNoIncrementTag>(p);
-        return result;
-    }
-    return result;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::isStrong() const
-{
-    return !(tp_ & tagMask);
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::isWeak() const
-{
-    return tp_ & tagMask;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::convertToStrong()
-{
-    if (isStrong())
-        return true;
-
-    auto p = unsafeGetRawPtr();
-    if (p && p->checkoutStrongRefFromWeak())
-    {
-        [[maybe_unused]] auto action = p->releaseWeakRef();
-        XRPL_ASSERT(
-            (action == ReleaseWeakRefAction::noop),
-            "ripple::SharedWeakUnion::convertToStrong : "
-            "action is noop");
-        unsafeSetRawPtr(p, RefStrength::strong);
-        return true;
-    }
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::convertToWeak()
-{
-    if (isWeak())
-        return true;
-
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return false;
-
-    using enum ReleaseStrongRefAction;
-    auto action = p->addWeakReleaseStrongRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            // We just added a weak ref. How could we destroy?
-            UNREACHABLE(
-                "ripple::SharedWeakUnion::convertToWeak : destroying freshly "
-                "added ref");
-            delete p;
-            unsafeSetRawPtr(nullptr);
-            return true;  // Should never happen
-        case partialDestroy:
-            // This is a weird case. We just converted the last strong
-            // pointer to a weak pointer.
-            p->partialDestructor();
-            partialDestructorFinished(&p);
-            // p is null and may no longer be used
-            break;
-    }
-    unsafeSetRawPtr(p, RefStrength::weak);
-    return true;
-}
-
-template <class T>
-T*
-SharedWeakUnion<T>::unsafeGetRawPtr() const
-{
-    return reinterpret_cast<T*>(tp_ & ptrMask);
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeSetRawPtr(T* p, RefStrength rs)
-{
-    tp_ = reinterpret_cast<std::uintptr_t>(p);
-    if (tp_ && rs == RefStrength::weak)
-        tp_ |= tagMask;
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeSetRawPtr(std::nullptr_t)
-{
-    tp_ = 0;
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeReleaseNoStore()
-{
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return;
-
-    if (isStrong())
-    {
-        using enum ReleaseStrongRefAction;
-        auto strongAction = p->releaseStrongRef();
-        switch (strongAction)
-        {
-            case noop:
-                break;
-            case destroy:
-                delete p;
-                break;
-            case partialDestroy:
-                p->partialDestructor();
-                partialDestructorFinished(&p);
-                // p is null and may no longer be used
-                break;
-        }
-    }
-    else
-    {
-        using enum ReleaseWeakRefAction;
-        auto weakAction = p->releaseWeakRef();
-        switch (weakAction)
-        {
-            case noop:
-                break;
-            case destroy:
-                delete p;
-                break;
-        }
-    }
-}
-
-}  // namespace ripple
-#endif

include/xrpl/basics/IntrusiveRefCounts.h

@@ -1,502 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEREFCOUNTS_H_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEREFCOUNTS_H_INCLUDED
-
-#include <xrpl/beast/utility/instrumentation.h>
-
-#include <atomic>
-#include <cstdint>
-
-namespace ripple {
-
-/** Action to perform when releasing a strong pointer.
-
-    noop: Do nothing. For example, a `noop` action will occur when a count is
-    decremented to a non-zero value.
-
-    partialDestroy: Run the `partialDestructor`. This action will happen when a
-    strong count is decremented to zero and the weak count is non-zero.
-
-    destroy: Run the destructor. This action will occur when either the strong
-    count or weak count is decremented and the other count is also zero.
- */
-enum class ReleaseStrongRefAction { noop, partialDestroy, destroy };
-
-/** Action to perform when releasing a weak pointer.
-
-    noop: Do nothing. For example, a `noop` action will occur when a count is
-    decremented to a non-zero value.
-
-    destroy: Run the destructor. This action will occur when either the strong
-    count or weak count is decremented and the other count is also zero.
- */
-enum class ReleaseWeakRefAction { noop, destroy };
-
-/** Implement the strong count, weak count, and bit flags for an intrusive
-    pointer.
-
-    A class can satisfy the requirements of a ripple::IntrusivePointer by
-    inheriting from this class.
-  */
-struct IntrusiveRefCounts
-{
-    virtual ~IntrusiveRefCounts() noexcept;
-
-    // This must be `noexcept` or the make_SharedIntrusive function could leak
-    // memory.
-    void
-    addStrongRef() const noexcept;
-
-    void
-    addWeakRef() const noexcept;
-
-    ReleaseStrongRefAction
-    releaseStrongRef() const;
-
-    // Same as:
-    // {
-    //   addWeakRef();
-    //   return releaseStrongRef;
-    // }
-    // done as one atomic operation
-    ReleaseStrongRefAction
-    addWeakReleaseStrongRef() const;
-
-    ReleaseWeakRefAction
-    releaseWeakRef() const;
-
-    // Returns true is able to checkout a strong ref. False otherwise
-    bool
-    checkoutStrongRefFromWeak() const noexcept;
-
-    bool
-    expired() const noexcept;
-
-    std::size_t
-    use_count() const noexcept;
-
-    // This function MUST be called after a partial destructor finishes running.
-    // Calling this function may cause other threads to delete the object
-    // pointed to by `o`, so `o` should never be used after calling this
-    // function. The parameter will be set to a `nullptr` after calling this
-    // function to emphasize that it should not be used.
-    // Note: This is intentionally NOT called at the end of `partialDestructor`.
-    // The reason for this is if new classes are written to support this smart
-    // pointer class, they need to write their own `partialDestructor` function
-    // and ensure `partialDestructorFinished` is called at the end. Putting this
-    // call inside the smart pointer class itself is expected to be less error
-    // prone.
-    // Note: The "two-star" programming is intentional. It emphasizes that `o`
-    // may be deleted and the unergonomic API is meant to signal the special
-    // nature of this function call to callers.
-    // Note: This is a template to support incompletely defined classes.
-    template <class T>
-    friend void
-    partialDestructorFinished(T** o);
-
-private:
-    // TODO: We may need to use a uint64_t for both counts. This will reduce the
-    // memory savings. We need to audit the code to make sure 16 bit counts are
-    // 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 StrongCountNumBits = sizeof(CountType) * 8;
-    static constexpr size_t WeakCountNumBits = StrongCountNumBits - 2;
-    using FieldType = std::uint32_t;
-    static constexpr size_t FieldTypeBits = sizeof(FieldType) * 8;
-    static constexpr FieldType one = 1;
-
-    /** `refCounts` consists of four fields that are treated atomically:
-
-         1. Strong count. This is a count of the number of shared pointers that
-         hold a reference to this object. When the strong counts goes to zero,
-         if the weak count is zero, the destructor is run. If the weak count is
-         non-zero when the strong count goes to zero then the partialDestructor
-         is run.
-
-         2. Weak count. This is a count of the number of weak pointer that hold
-         a reference to this object. When the weak count goes to zero and the
-         strong count is also zero, then the destructor is run.
-
-         3. Partial destroy started bit. This bit is set if the
-         `partialDestructor` function has been started (or is about to be
-         started). This is used to prevent the destructor from running
-         concurrently with the partial destructor. This can easily happen when
-         the last strong pointer release its reference in one thread and starts
-         the partialDestructor, while in another thread the last weak pointer
-         goes out of scope and starts the destructor while the partialDestructor
-         is still running. Both a start and finished bit is needed to handle a
-         corner-case where the last strong pointer goes out of scope, then then
-         last `weakPointer` goes out of scope, but this happens before the
-         `partialDestructor` bit is set. It would be possible to use a single
-         bit if it could also be set atomically when the strong count goes to
-         zero and the weak count is non-zero, but that would add complexity (and
-         likely slow down common cases as well).
-
-         4. Partial destroy finished bit. This bit is set when the
-         `partialDestructor` has finished running. See (3) above for more
-         information.
-
-         */
-
-    mutable std::atomic<FieldType> refCounts{strongDelta};
-
-    /**  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 strongDelta = 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 weakDelta = (one << StrongCountNumBits);
-
-    /**  Flag that is set when the partialDestroy function has started running
-         (or is about to start running).
-
-         See description of the `refCounts` field for a fuller description of
-         this field.
-      */
-    static constexpr FieldType partialDestroyStartedMask =
-        (one << (FieldTypeBits - 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 partialDestroyFinishedMask =
-        (one << (FieldTypeBits - 2));
-
-    /** Mask that will zero out all the `count` bits and leave the tag bits
-        unchanged.
-      */
-    static constexpr FieldType tagMask =
-        partialDestroyStartedMask | partialDestroyFinishedMask;
-
-    /** Mask that will zero out the `tag` bits and leave the count bits
-        unchanged.
-      */
-    static constexpr FieldType valueMask = ~tagMask;
-
-    /** Mask that will zero out everything except the strong count.
-     */
-    static constexpr FieldType strongMask =
-        ((one << StrongCountNumBits) - 1) & valueMask;
-
-    /** Mask that will zero out everything except the weak count.
-     */
-    static constexpr FieldType weakMask =
-        (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
-
-    /** Unpack the count and tag fields from the packed atomic integer form. */
-    struct RefCountPair
-    {
-        CountType strong;
-        CountType weak;
-        /**  The `partialDestroyStartedBit` is set to on when the partial
-             destroy function is started. It is not a boolean; it is a uint32
-             with all bits zero with the possible exception of the
-             `partialDestroyStartedMask` bit. This is done so it can be directly
-             masked into the `combinedValue`.
-         */
-        FieldType partialDestroyStartedBit{0};
-        /**  The `partialDestroyFinishedBit` is set to on when the partial
-             destroy function has finished.
-         */
-        FieldType partialDestroyFinishedBit{0};
-        RefCountPair(FieldType v) noexcept;
-        RefCountPair(CountType s, CountType w) noexcept;
-
-        /** Convert back to the packed integer form. */
-        FieldType
-        combinedValue() const noexcept;
-
-        static constexpr CountType maxStrongValue =
-            static_cast<CountType>((one << StrongCountNumBits) - 1);
-        static constexpr CountType maxWeakValue =
-            static_cast<CountType>((one << WeakCountNumBits) - 1);
-        /**  Put an extra margin to detect when running up against limits.
-             This is only used in debug code, and is useful if we reduce the
-             number of bits in the strong and weak counts (to 16 and 14 bits).
-         */
-        static constexpr CountType checkStrongMaxValue = maxStrongValue - 32;
-        static constexpr CountType checkWeakMaxValue = maxWeakValue - 32;
-    };
-};
-
-inline void
-IntrusiveRefCounts::addStrongRef() const noexcept
-{
-    refCounts.fetch_add(strongDelta, std::memory_order_acq_rel);
-}
-
-inline void
-IntrusiveRefCounts::addWeakRef() const noexcept
-{
-    refCounts.fetch_add(weakDelta, std::memory_order_acq_rel);
-}
-
-inline ReleaseStrongRefAction
-IntrusiveRefCounts::releaseStrongRef() const
-{
-    // Subtract `strongDelta` from refCounts. If this releases the last strong
-    // ref, set the `partialDestroyStarted` bit. It is important that the ref
-    // count and the `partialDestroyStartedBit` are changed atomically (hence
-    // the loop and `compare_exchange` op). If this didn't need to be done
-    // atomically, the loop could be replaced with a `fetch_sub` and a
-    // conditional `fetch_or`. This loop will almost always run once.
-
-    using enum ReleaseStrongRefAction;
-    auto prevIntVal = refCounts.load(std::memory_order_acquire);
-    while (1)
-    {
-        RefCountPair const prevVal{prevIntVal};
-        XRPL_ASSERT(
-            (prevVal.strong >= strongDelta),
-            "ripple::IntrusiveRefCounts::releaseStrongRef : previous ref "
-            "higher than new");
-        auto nextIntVal = prevIntVal - strongDelta;
-        ReleaseStrongRefAction action = noop;
-        if (prevVal.strong == 1)
-        {
-            if (prevVal.weak == 0)
-            {
-                action = destroy;
-            }
-            else
-            {
-                nextIntVal |= partialDestroyStartedMask;
-                action = partialDestroy;
-            }
-        }
-
-        if (refCounts.compare_exchange_weak(
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
-        {
-            // Can't be in partial destroy because only decrementing the strong
-            // count to zero can start a partial destroy, and that can't happen
-            // twice.
-            XRPL_ASSERT(
-                (action == noop) || !(prevIntVal & partialDestroyStartedMask),
-                "ripple::IntrusiveRefCounts::releaseStrongRef : not in partial "
-                "destroy");
-            return action;
-        }
-    }
-}
-
-inline ReleaseStrongRefAction
-IntrusiveRefCounts::addWeakReleaseStrongRef() const
-{
-    using enum ReleaseStrongRefAction;
-
-    static_assert(weakDelta > strongDelta);
-    auto constexpr delta = weakDelta - strongDelta;
-    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
-    // the flags depend on the current value of the counts).
-    //
-    // Note: If this becomes a perf bottleneck, the `partialDestoryStartedMask`
-    // may be able to be set non-atomically. But it is easier to reason about
-    // the code if the flag is set atomically.
-    while (1)
-    {
-        RefCountPair const prevVal{prevIntVal};
-        // Converted the last strong pointer to a weak pointer.
-        //
-        // Can't be in partial destroy because only decrementing the
-        // strong count to zero can start a partial destroy, and that
-        // can't happen twice.
-        XRPL_ASSERT(
-            (!prevVal.partialDestroyStartedBit),
-            "ripple::IntrusiveRefCounts::addWeakReleaseStrongRef : not in "
-            "partial destroy");
-
-        auto nextIntVal = prevIntVal + delta;
-        ReleaseStrongRefAction action = noop;
-        if (prevVal.strong == 1)
-        {
-            if (prevVal.weak == 0)
-            {
-                action = noop;
-            }
-            else
-            {
-                nextIntVal |= partialDestroyStartedMask;
-                action = partialDestroy;
-            }
-        }
-        if (refCounts.compare_exchange_weak(
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
-        {
-            XRPL_ASSERT(
-                (!(prevIntVal & partialDestroyStartedMask)),
-                "ripple::IntrusiveRefCounts::addWeakReleaseStrongRef : not "
-                "started partial destroy");
-            return action;
-        }
-    }
-}
-
-inline ReleaseWeakRefAction
-IntrusiveRefCounts::releaseWeakRef() const
-{
-    auto prevIntVal = refCounts.fetch_sub(weakDelta, std::memory_order_acq_rel);
-    RefCountPair prev = prevIntVal;
-    if (prev.weak == 1 && prev.strong == 0)
-    {
-        if (!prev.partialDestroyStartedBit)
-        {
-            // This case should only be hit if the partialDestroyStartedBit is
-            // set non-atomically (and even then very rarely). The code is kept
-            // in case we need to set the flag non-atomically for perf reasons.
-            refCounts.wait(prevIntVal, std::memory_order_acquire);
-            prevIntVal = refCounts.load(std::memory_order_acquire);
-            prev = RefCountPair{prevIntVal};
-        }
-        if (!prev.partialDestroyFinishedBit)
-        {
-            // partial destroy MUST finish before running a full destroy (when
-            // using weak pointers)
-            refCounts.wait(prevIntVal - weakDelta, std::memory_order_acquire);
-        }
-        return ReleaseWeakRefAction::destroy;
-    }
-    return ReleaseWeakRefAction::noop;
-}
-
-inline bool
-IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
-{
-    auto curValue = RefCountPair{1, 1}.combinedValue();
-    auto desiredValue = RefCountPair{2, 1}.combinedValue();
-
-    while (!refCounts.compare_exchange_weak(
-        curValue, desiredValue, std::memory_order_acq_rel))
-    {
-        RefCountPair const prev{curValue};
-        if (!prev.strong)
-            return false;
-
-        desiredValue = curValue + strongDelta;
-    }
-    return true;
-}
-
-inline bool
-IntrusiveRefCounts::expired() const noexcept
-{
-    RefCountPair const val = refCounts.load(std::memory_order_acquire);
-    return val.strong == 0;
-}
-
-inline std::size_t
-IntrusiveRefCounts::use_count() const noexcept
-{
-    RefCountPair const val = refCounts.load(std::memory_order_acquire);
-    return val.strong;
-}
-
-inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept
-{
-#ifndef NDEBUG
-    auto v = refCounts.load(std::memory_order_acquire);
-    XRPL_ASSERT(
-        (!(v & valueMask)),
-        "ripple::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
-    auto t = v & tagMask;
-    XRPL_ASSERT(
-        (!t || t == tagMask),
-        "ripple::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline IntrusiveRefCounts::RefCountPair::RefCountPair(
-    IntrusiveRefCounts::FieldType v) noexcept
-    : strong{static_cast<CountType>(v & strongMask)}
-    , weak{static_cast<CountType>((v & weakMask) >> StrongCountNumBits)}
-    , partialDestroyStartedBit{v & partialDestroyStartedMask}
-    , partialDestroyFinishedBit{v & partialDestroyFinishedMask}
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair(FieldType) : inputs inside "
-        "range");
-}
-
-inline IntrusiveRefCounts::RefCountPair::RefCountPair(
-    IntrusiveRefCounts::CountType s,
-    IntrusiveRefCounts::CountType w) noexcept
-    : strong{s}, weak{w}
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair(CountType, CountType) : "
-        "inputs inside range");
-}
-
-inline IntrusiveRefCounts::FieldType
-IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair::combinedValue : inputs "
-        "inside range");
-    return (static_cast<IntrusiveRefCounts::FieldType>(weak)
-            << IntrusiveRefCounts::StrongCountNumBits) |
-        static_cast<IntrusiveRefCounts::FieldType>(strong) |
-        partialDestroyStartedBit | partialDestroyFinishedBit;
-}
-
-template <class T>
-inline void
-partialDestructorFinished(T** o)
-{
-    T& self = **o;
-    IntrusiveRefCounts::RefCountPair p =
-        self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
-    XRPL_ASSERT(
-        (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit &&
-         !p.strong),
-        "ripple::partialDestructorFinished : not a weak ref");
-    if (!p.weak)
-    {
-        // There was a weak count before the partial destructor ran (or we would
-        // have run the full destructor) and now there isn't a weak count. Some
-        // thread is waiting to run the destructor.
-        self.refCounts.notify_one();
-    }
-    // Set the pointer to null to emphasize that the object shouldn't be used
-    // after calling this function as it may be destroyed in another thread.
-    *o = nullptr;
-}
-//------------------------------------------------------------------------------
-
-}  // namespace ripple
-#endif

include/xrpl/basics/LocalValue.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_LOCALVALUE_H_INCLUDED
 
 #include <boost/thread/tss.hpp>
-
 #include <memory>
 #include <unordered_map>
 

include/xrpl/basics/Log.h

@@ -22,10 +22,8 @@
 
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/beast/utility/Journal.h>
-
 #include <boost/beast/core/string.hpp>
 #include <boost/filesystem.hpp>
-
 #include <fstream>
 #include <map>
 #include <memory>

include/xrpl/basics/Resolver.h

@@ -20,11 +20,11 @@
 #ifndef RIPPLE_BASICS_RESOLVER_H_INCLUDED
 #define RIPPLE_BASICS_RESOLVER_H_INCLUDED
 
-#include <xrpl/beast/net/IPEndpoint.h>
-
 #include <functional>
 #include <vector>
 
+#include <xrpl/beast/net/IPEndpoint.h>
+
 namespace ripple {
 
 class Resolver

include/xrpl/basics/ResolverAsio.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/basics/Resolver.h>
 #include <xrpl/beast/utility/Journal.h>
-
 #include <boost/asio/io_service.hpp>
 
 namespace ripple {

include/xrpl/basics/SharedWeakCachePointer.h

@@ -1,135 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
-#define RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
-
-#include <memory>
-#include <variant>
-
-namespace ripple {
-
-/** A combination of a std::shared_ptr and a std::weak_pointer.
-
-
-This class is a wrapper to a `std::variant<std::shared_ptr,std::weak_ptr>`
-This class is useful for storing intrusive pointers in tagged caches using less
-memory than storing both pointers directly.
-*/
-
-template <class T>
-class SharedWeakCachePointer
-{
-public:
-    SharedWeakCachePointer() = default;
-
-    SharedWeakCachePointer(SharedWeakCachePointer const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer(std::shared_ptr<TT> const& rhs);
-
-    SharedWeakCachePointer(SharedWeakCachePointer&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer(std::shared_ptr<TT>&& rhs);
-
-    SharedWeakCachePointer&
-    operator=(SharedWeakCachePointer const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer&
-    operator=(std::shared_ptr<TT> const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer&
-    operator=(std::shared_ptr<TT>&& rhs);
-
-    ~SharedWeakCachePointer();
-
-    /** Return a strong pointer if this is already a strong pointer (i.e. don't
-        lock the weak pointer. Use the `lock` method if that's what's needed)
-     */
-    std::shared_ptr<T> const&
-    getStrong() const;
-
-    /** Return true if this is a strong pointer and the strong pointer is
-        seated.
-     */
-    explicit
-    operator bool() const noexcept;
-
-    /** Set the pointer to null, decrement the appropriate ref count, and run
-        the appropriate release action.
-     */
-    void
-    reset();
-
-    /** If this is a strong pointer, return the raw pointer. Otherwise return
-        null.
-     */
-    T*
-    get() const;
-
-    /** If this is a strong pointer, return the strong count. Otherwise return 0
-     */
-    std::size_t
-    use_count() const;
-
-    /** Return true if there is a non-zero strong count. */
-    bool
-    expired() const;
-
-    /** If this is a strong pointer, return the strong pointer. Otherwise
-        attempt to lock the weak pointer.
-     */
-    std::shared_ptr<T>
-    lock() const;
-
-    /** Return true is this represents a strong pointer. */
-    bool
-    isStrong() const;
-
-    /** Return true is this represents a weak pointer. */
-    bool
-    isWeak() const;
-
-    /** If this is a weak pointer, attempt to convert it to a strong pointer.
-
-        @return true if successfully converted to a strong pointer (or was
-                already a strong pointer). Otherwise false.
-      */
-    bool
-    convertToStrong();
-
-    /** If this is a strong pointer, attempt to convert it to a weak pointer.
-
-        @return false if the pointer is null. Otherwise return true.
-      */
-    bool
-    convertToWeak();
-
-private:
-    std::variant<std::shared_ptr<T>, std::weak_ptr<T>> combo_;
-};
-}  // namespace ripple
-#endif

include/xrpl/basics/SharedWeakCachePointer.ipp

@@ -1,192 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_IPP_INCLUDED
-#define RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_IPP_INCLUDED
-
-#include <xrpl/basics/SharedWeakCachePointer.h>
-
-namespace ripple {
-template <class T>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    SharedWeakCachePointer const& rhs) = default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    std::shared_ptr<TT> const& rhs)
-    : combo_{rhs}
-{
-}
-
-template <class T>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    SharedWeakCachePointer&& rhs) = default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs)
-    : combo_{std::move(rhs)}
-{
-}
-
-template <class T>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(SharedWeakCachePointer const& rhs) =
-    default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(std::shared_ptr<TT> const& rhs)
-{
-    combo_ = rhs;
-    return *this;
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(std::shared_ptr<TT>&& rhs)
-{
-    combo_ = std::move(rhs);
-    return *this;
-}
-
-template <class T>
-SharedWeakCachePointer<T>::~SharedWeakCachePointer() = default;
-
-// Return a strong pointer if this is already a strong pointer (i.e. don't
-// lock the weak pointer. Use the `lock` method if that's what's needed)
-template <class T>
-std::shared_ptr<T> const&
-SharedWeakCachePointer<T>::getStrong() const
-{
-    static std::shared_ptr<T> const empty;
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return *p;
-    return empty;
-}
-
-template <class T>
-SharedWeakCachePointer<T>::operator bool() const noexcept
-{
-    return !!std::get_if<std::shared_ptr<T>>(&combo_);
-}
-
-template <class T>
-void
-SharedWeakCachePointer<T>::reset()
-{
-    combo_ = std::shared_ptr<T>{};
-}
-
-template <class T>
-T*
-SharedWeakCachePointer<T>::get() const
-{
-    return std::get_if<std::shared_ptr<T>>(&combo_).get();
-}
-
-template <class T>
-std::size_t
-SharedWeakCachePointer<T>::use_count() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::expired() const
-{
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-        return p->expired();
-    return !std::get_if<std::shared_ptr<T>>(&combo_);
-}
-
-template <class T>
-std::shared_ptr<T>
-SharedWeakCachePointer<T>::lock() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return *p;
-
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-        return p->lock();
-
-    return {};
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::isStrong() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return !!p->get();
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::isWeak() const
-{
-    return !isStrong();
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::convertToStrong()
-{
-    if (isStrong())
-        return true;
-
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-    {
-        if (auto s = p->lock())
-        {
-            combo_ = std::move(s);
-            return true;
-        }
-    }
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::convertToWeak()
-{
-    if (isWeak())
-        return true;
-
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-    {
-        combo_ = std::weak_ptr<T>(*p);
-        return true;
-    }
-
-    return false;
-}
-}  // namespace ripple
-#endif

include/xrpl/basics/Slice.h

@@ -23,7 +23,6 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <algorithm>
 #include <array>
 #include <cstdint>

include/xrpl/basics/StringUtilities.h

@@ -29,6 +29,7 @@
 #include <array>
 #include <cstdint>
 #include <optional>
+#include <sstream>
 #include <string>
 
 namespace ripple {

include/xrpl/basics/TaggedCache.h

@@ -20,14 +20,11 @@
 #ifndef RIPPLE_BASICS_TAGGEDCACHE_H_INCLUDED
 #define RIPPLE_BASICS_TAGGEDCACHE_H_INCLUDED
 
-#include <xrpl/basics/IntrusivePointer.h>
 #include <xrpl/basics/Log.h>
-#include <xrpl/basics/SharedWeakCachePointer.ipp>
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/basics/hardened_hash.h>
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/insight/Insight.h>
-
 #include <atomic>
 #include <functional>
 #include <mutex>
@@ -53,8 +50,6 @@ template <
     class Key,
     class T,
     bool IsKeyCache = false,
-    class SharedWeakUnionPointerType = SharedWeakCachePointer<T>,
-    class SharedPointerType = std::shared_ptr<T>,
     class Hash = hardened_hash<>,
     class KeyEqual = std::equal_to<Key>,
     class Mutex = std::recursive_mutex>
@@ -65,8 +60,6 @@ public:
     using key_type = Key;
     using mapped_type = T;
     using clock_type = beast::abstract_clock<std::chrono::steady_clock>;
-    using shared_weak_combo_pointer_type = SharedWeakUnionPointerType;
-    using shared_pointer_type = SharedPointerType;
 
 public:
     TaggedCache(
@@ -76,48 +69,231 @@ public:
         clock_type& clock,
         beast::Journal journal,
         beast::insight::Collector::ptr const& collector =
-            beast::insight::NullCollector::New());
+            beast::insight::NullCollector::New())
+        : m_journal(journal)
+        , m_clock(clock)
+        , m_stats(
+              name,
+              std::bind(&TaggedCache::collect_metrics, this),
+              collector)
+        , m_name(name)
+        , m_target_size(size)
+        , m_target_age(expiration)
+        , m_cache_count(0)
+        , m_hits(0)
+        , m_misses(0)
+    {
+    }
 
 public:
     /** Return the clock associated with the cache. */
     clock_type&
-    clock();
+    clock()
+    {
+        return m_clock;
+    }
 
     /** Returns the number of items in the container. */
     std::size_t
-    size() const;
+    size() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache.size();
+    }
+
+    void
+    setTargetSize(int s)
+    {
+        std::lock_guard lock(m_mutex);
+        m_target_size = s;
+
+        if (s > 0)
+        {
+            for (auto& partition : m_cache.map())
+            {
+                partition.rehash(static_cast<std::size_t>(
+                    (s + (s >> 2)) /
+                        (partition.max_load_factor() * m_cache.partitions()) +
+                    1));
+            }
+        }
+
+        JLOG(m_journal.debug()) << m_name << " target size set to " << s;
+    }
+
+    clock_type::duration
+    getTargetAge() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_target_age;
+    }
+
+    void
+    setTargetAge(clock_type::duration s)
+    {
+        std::lock_guard lock(m_mutex);
+        m_target_age = s;
+        JLOG(m_journal.debug())
+            << m_name << " target age set to " << m_target_age.count();
+    }
 
     int
-    getCacheSize() const;
+    getCacheSize() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache_count;
+    }
 
     int
-    getTrackSize() const;
+    getTrackSize() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache.size();
+    }
 
     float
-    getHitRate();
+    getHitRate()
+    {
+        std::lock_guard lock(m_mutex);
+        auto const total = static_cast<float>(m_hits + m_misses);
+        return m_hits * (100.0f / std::max(1.0f, total));
+    }
 
     void
-    clear();
+    clear()
+    {
+        std::lock_guard lock(m_mutex);
+        m_cache.clear();
+        m_cache_count = 0;
+    }
 
     void
-    reset();
+    reset()
+    {
+        std::lock_guard lock(m_mutex);
+        m_cache.clear();
+        m_cache_count = 0;
+        m_hits = 0;
+        m_misses = 0;
+    }
 
     /** Refresh the last access time on a key if present.
         @return `true` If the key was found.
     */
     template <class KeyComparable>
     bool
-    touch_if_exists(KeyComparable const& key);
+    touch_if_exists(KeyComparable const& key)
+    {
+        std::lock_guard lock(m_mutex);
+        auto const iter(m_cache.find(key));
+        if (iter == m_cache.end())
+        {
+            ++m_stats.misses;
+            return false;
+        }
+        iter->second.touch(m_clock.now());
+        ++m_stats.hits;
+        return true;
+    }
 
-    using SweptPointersVector = std::vector<SharedWeakUnionPointerType>;
+    using SweptPointersVector = std::pair<
+        std::vector<std::shared_ptr<mapped_type>>,
+        std::vector<std::weak_ptr<mapped_type>>>;
 
     void
-    sweep();
+    sweep()
+    {
+        // Keep references to all the stuff we sweep
+        // For performance, each worker thread should exit before the swept data
+        // is destroyed but still within the main cache lock.
+        std::vector<SweptPointersVector> allStuffToSweep(m_cache.partitions());
+
+        clock_type::time_point const now(m_clock.now());
+        clock_type::time_point when_expire;
+
+        auto const start = std::chrono::steady_clock::now();
+        {
+            std::lock_guard lock(m_mutex);
+
+            if (m_target_size == 0 ||
+                (static_cast<int>(m_cache.size()) <= m_target_size))
+            {
+                when_expire = now - m_target_age;
+            }
+            else
+            {
+                when_expire =
+                    now - m_target_age * m_target_size / m_cache.size();
+
+                clock_type::duration const minimumAge(std::chrono::seconds(1));
+                if (when_expire > (now - minimumAge))
+                    when_expire = now - minimumAge;
+
+                JLOG(m_journal.trace())
+                    << m_name << " is growing fast " << m_cache.size() << " of "
+                    << m_target_size << " aging at "
+                    << (now - when_expire).count() << " of "
+                    << m_target_age.count();
+            }
+
+            std::vector<std::thread> workers;
+            workers.reserve(m_cache.partitions());
+            std::atomic<int> allRemovals = 0;
+
+            for (std::size_t p = 0; p < m_cache.partitions(); ++p)
+            {
+                workers.push_back(sweepHelper(
+                    when_expire,
+                    now,
+                    m_cache.map()[p],
+                    allStuffToSweep[p],
+                    allRemovals,
+                    lock));
+            }
+            for (std::thread& worker : workers)
+                worker.join();
+
+            m_cache_count -= allRemovals;
+        }
+        // At this point allStuffToSweep will go out of scope outside the lock
+        // and decrement the reference count on each strong pointer.
+        JLOG(m_journal.debug())
+            << m_name << " TaggedCache sweep lock duration "
+            << std::chrono::duration_cast<std::chrono::milliseconds>(
+                   std::chrono::steady_clock::now() - start)
+                   .count()
+            << "ms";
+    }
 
     bool
-    del(key_type const& key, bool valid);
+    del(const key_type& key, bool valid)
+    {
+        // Remove from cache, if !valid, remove from map too. Returns true if
+        // removed from cache
+        std::lock_guard lock(m_mutex);
+
+        auto cit = m_cache.find(key);
+
+        if (cit == m_cache.end())
+            return false;
+
+        Entry& entry = cit->second;
+
+        bool ret = false;
+
+        if (entry.isCached())
+        {
+            --m_cache_count;
+            entry.ptr.reset();
+            ret = true;
+        }
+
+        if (!valid || entry.isExpired())
+            m_cache.erase(cit);
+
+        return ret;
+    }
 
-public:
     /** Replace aliased objects with originals.
 
         Due to concurrency it is possible for two separate objects with
@@ -131,23 +307,100 @@ public:
 
         @return `true` If the key already existed.
     */
-    template <class R>
+public:
     bool
     canonicalize(
-        key_type const& key,
-        SharedPointerType& data,
-        R&& replaceCallback);
+        const key_type& key,
+        std::shared_ptr<T>& data,
+        std::function<bool(std::shared_ptr<T> const&)>&& replace)
+    {
+        // Return canonical value, store if needed, refresh in cache
+        // Return values: true=we had the data already
+        std::lock_guard lock(m_mutex);
+
+        auto cit = m_cache.find(key);
+
+        if (cit == m_cache.end())
+        {
+            m_cache.emplace(
+                std::piecewise_construct,
+                std::forward_as_tuple(key),
+                std::forward_as_tuple(m_clock.now(), data));
+            ++m_cache_count;
+            return false;
+        }
+
+        Entry& entry = cit->second;
+        entry.touch(m_clock.now());
+
+        if (entry.isCached())
+        {
+            if (replace(entry.ptr))
+            {
+                entry.ptr = data;
+                entry.weak_ptr = data;
+            }
+            else
+            {
+                data = entry.ptr;
+            }
+
+            return true;
+        }
+
+        auto cachedData = entry.lock();
+
+        if (cachedData)
+        {
+            if (replace(entry.ptr))
+            {
+                entry.ptr = data;
+                entry.weak_ptr = data;
+            }
+            else
+            {
+                entry.ptr = cachedData;
+                data = cachedData;
+            }
+
+            ++m_cache_count;
+            return true;
+        }
+
+        entry.ptr = data;
+        entry.weak_ptr = data;
+        ++m_cache_count;
+
+        return false;
+    }
 
     bool
     canonicalize_replace_cache(
-        key_type const& key,
-        SharedPointerType const& data);
+        const key_type& key,
+        std::shared_ptr<T> const& data)
+    {
+        return canonicalize(
+            key,
+            const_cast<std::shared_ptr<T>&>(data),
+            [](std::shared_ptr<T> const&) { return true; });
+    }
 
     bool
-    canonicalize_replace_client(key_type const& key, SharedPointerType& data);
+    canonicalize_replace_client(const key_type& key, std::shared_ptr<T>& data)
+    {
+        return canonicalize(
+            key, data, [](std::shared_ptr<T> const&) { return false; });
+    }
 
-    SharedPointerType
-    fetch(key_type const& key);
+    std::shared_ptr<T>
+    fetch(const key_type& key)
+    {
+        std::lock_guard<mutex_type> l(m_mutex);
+        auto ret = initialFetch(key, l);
+        if (!ret)
+            ++m_misses;
+        return ret;
+    }
 
     /** Insert the element into the container.
         If the key already exists, nothing happens.
@@ -156,11 +409,26 @@ public:
     template <class ReturnType = bool>
     auto
     insert(key_type const& key, T const& value)
-        -> std::enable_if_t<!IsKeyCache, ReturnType>;
+        -> std::enable_if_t<!IsKeyCache, ReturnType>
+    {
+        auto p = std::make_shared<T>(std::cref(value));
+        return canonicalize_replace_client(key, p);
+    }
 
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>;
+    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
+    {
+        std::lock_guard lock(m_mutex);
+        clock_type::time_point const now(m_clock.now());
+        auto [it, inserted] = m_cache.emplace(
+            std::piecewise_construct,
+            std::forward_as_tuple(key),
+            std::forward_as_tuple(now));
+        if (!inserted)
+            it->second.last_access = now;
+        return inserted;
+    }
 
     // VFALCO NOTE It looks like this returns a copy of the data in
     //             the output parameter 'data'. This could be expensive.
@@ -168,18 +436,50 @@ public:
     //             simply return an iterator.
     //
     bool
-    retrieve(key_type const& key, T& data);
+    retrieve(const key_type& key, T& data)
+    {
+        // retrieve the value of the stored data
+        auto entry = fetch(key);
+
+        if (!entry)
+            return false;
+
+        data = *entry;
+        return true;
+    }
 
     mutex_type&
-    peekMutex();
+    peekMutex()
+    {
+        return m_mutex;
+    }
 
     std::vector<key_type>
-    getKeys() const;
+    getKeys() const
+    {
+        std::vector<key_type> v;
+
+        {
+            std::lock_guard lock(m_mutex);
+            v.reserve(m_cache.size());
+            for (auto const& _ : m_cache)
+                v.push_back(_.first);
+        }
+
+        return v;
+    }
 
     // CachedSLEs functions.
     /** Returns the fraction of cache hits. */
     double
-    rate() const;
+    rate() const
+    {
+        std::lock_guard lock(m_mutex);
+        auto const tot = m_hits + m_misses;
+        if (tot == 0)
+            return 0;
+        return double(m_hits) / tot;
+    }
 
     /** Fetch an item from the cache.
         If the digest was not found, Handler
@@ -187,16 +487,73 @@ public:
             std::shared_ptr<SLE const>(void)
     */
     template <class Handler>
-    SharedPointerType
-    fetch(key_type const& digest, Handler const& h);
+    std::shared_ptr<T>
+    fetch(key_type const& digest, Handler const& h)
+    {
+        {
+            std::lock_guard l(m_mutex);
+            if (auto ret = initialFetch(digest, l))
+                return ret;
+        }
+
+        auto sle = h();
+        if (!sle)
+            return {};
+
+        std::lock_guard l(m_mutex);
+        ++m_misses;
+        auto const [it, inserted] =
+            m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
+        if (!inserted)
+            it->second.touch(m_clock.now());
+        return it->second.ptr;
+    }
     // End CachedSLEs functions.
 
 private:
-    SharedPointerType
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l);
+    std::shared_ptr<T>
+    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
+    {
+        auto cit = m_cache.find(key);
+        if (cit == m_cache.end())
+            return {};
+
+        Entry& entry = cit->second;
+        if (entry.isCached())
+        {
+            ++m_hits;
+            entry.touch(m_clock.now());
+            return entry.ptr;
+        }
+        entry.ptr = entry.lock();
+        if (entry.isCached())
+        {
+            // independent of cache size, so not counted as a hit
+            ++m_cache_count;
+            entry.touch(m_clock.now());
+            return entry.ptr;
+        }
+
+        m_cache.erase(cit);
+        return {};
+    }
 
     void
-    collect_metrics();
+    collect_metrics()
+    {
+        m_stats.size.set(getCacheSize());
+
+        {
+            beast::insight::Gauge::value_type hit_rate(0);
+            {
+                std::lock_guard lock(m_mutex);
+                auto const total(m_hits + m_misses);
+                if (total != 0)
+                    hit_rate = (m_hits * 100) / total;
+            }
+            m_stats.hit_rate.set(hit_rate);
+        }
+    }
 
 private:
     struct Stats
@@ -242,37 +599,36 @@ private:
     class ValueEntry
     {
     public:
-        shared_weak_combo_pointer_type ptr;
+        std::shared_ptr<mapped_type> ptr;
+        std::weak_ptr<mapped_type> weak_ptr;
         clock_type::time_point last_access;
 
         ValueEntry(
             clock_type::time_point const& last_access_,
-            shared_pointer_type const& ptr_)
-            : ptr(ptr_), last_access(last_access_)
+            std::shared_ptr<mapped_type> const& ptr_)
+            : ptr(ptr_), weak_ptr(ptr_), last_access(last_access_)
         {
         }
 
         bool
         isWeak() const
         {
-            if (!ptr)
-                return true;
-            return ptr.isWeak();
+            return ptr == nullptr;
         }
         bool
         isCached() const
         {
-            return ptr && ptr.isStrong();
+            return ptr != nullptr;
         }
         bool
         isExpired() const
         {
-            return ptr.expired();
+            return weak_ptr.expired();
         }
-        SharedPointerType
+        std::shared_ptr<mapped_type>
         lock()
         {
-            return ptr.lock();
+            return weak_ptr.lock();
         }
         void
         touch(clock_type::time_point const& now)
@@ -301,7 +657,72 @@ private:
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::lock_guard<std::recursive_mutex> const&)
+    {
+        return std::thread([&, this]() {
+            int cacheRemovals = 0;
+            int mapRemovals = 0;
+
+            // Keep references to all the stuff we sweep
+            // so that we can destroy them outside the lock.
+            stuffToSweep.first.reserve(partition.size());
+            stuffToSweep.second.reserve(partition.size());
+            {
+                auto cit = partition.begin();
+                while (cit != partition.end())
+                {
+                    if (cit->second.isWeak())
+                    {
+                        // weak
+                        if (cit->second.isExpired())
+                        {
+                            stuffToSweep.second.push_back(
+                                std::move(cit->second.weak_ptr));
+                            ++mapRemovals;
+                            cit = partition.erase(cit);
+                        }
+                        else
+                        {
+                            ++cit;
+                        }
+                    }
+                    else if (cit->second.last_access <= when_expire)
+                    {
+                        // strong, expired
+                        ++cacheRemovals;
+                        if (cit->second.ptr.use_count() == 1)
+                        {
+                            stuffToSweep.first.push_back(
+                                std::move(cit->second.ptr));
+                            ++mapRemovals;
+                            cit = partition.erase(cit);
+                        }
+                        else
+                        {
+                            // remains weakly cached
+                            cit->second.ptr.reset();
+                            ++cit;
+                        }
+                    }
+                    else
+                    {
+                        // strong, not expired
+                        ++cit;
+                    }
+                }
+            }
+
+            if (mapRemovals || cacheRemovals)
+            {
+                JLOG(m_journal.debug())
+                    << "TaggedCache partition sweep " << m_name
+                    << ": cache = " << partition.size() << "-" << cacheRemovals
+                    << ", map-=" << mapRemovals;
+            }
+
+            allRemovals += cacheRemovals;
+        });
+    }
 
     [[nodiscard]] std::thread
     sweepHelper(
@@ -310,7 +731,45 @@ private:
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::lock_guard<std::recursive_mutex> const&)
+    {
+        return std::thread([&, this]() {
+            int cacheRemovals = 0;
+            int mapRemovals = 0;
+
+            // Keep references to all the stuff we sweep
+            // so that we can destroy them outside the lock.
+            {
+                auto cit = partition.begin();
+                while (cit != partition.end())
+                {
+                    if (cit->second.last_access > now)
+                    {
+                        cit->second.last_access = now;
+                        ++cit;
+                    }
+                    else if (cit->second.last_access <= when_expire)
+                    {
+                        cit = partition.erase(cit);
+                    }
+                    else
+                    {
+                        ++cit;
+                    }
+                }
+            }
+
+            if (mapRemovals || cacheRemovals)
+            {
+                JLOG(m_journal.debug())
+                    << "TaggedCache partition sweep " << m_name
+                    << ": cache = " << partition.size() << "-" << cacheRemovals
+                    << ", map-=" << mapRemovals;
+            }
+
+            allRemovals += cacheRemovals;
+        });
+    };
 
     beast::Journal m_journal;
     clock_type& m_clock;
@@ -322,10 +781,10 @@ private:
     std::string m_name;
 
     // Desired number of cache entries (0 = ignore)
-    int const m_target_size;
+    int m_target_size;
 
     // Desired maximum cache age
-    clock_type::duration const m_target_age;
+    clock_type::duration m_target_age;
 
     // Number of items cached
     int m_cache_count;

include/xrpl/basics/UnorderedContainers.h

@@ -25,7 +25,6 @@
 #include <xrpl/beast/hash/hash_append.h>
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/hash/xxhasher.h>
-
 #include <unordered_map>
 #include <unordered_set>
 

include/xrpl/basics/algorithm.h

@@ -20,6 +20,7 @@
 #ifndef RIPPLE_ALGORITHM_H_INCLUDED
 #define RIPPLE_ALGORITHM_H_INCLUDED
 
+#include <iterator>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/base_uint.h

@@ -33,13 +33,12 @@
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/endian/conversion.hpp>
 #include <boost/functional/hash.hpp>
-
 #include <algorithm>
 #include <array>
 #include <cstring>
+#include <functional>
 #include <type_traits>
 
 namespace ripple {
@@ -386,7 +385,7 @@ public:
     }
 
     base_uint&
-    operator^=(base_uint const& b)
+    operator^=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] ^= b.data_[i];
@@ -395,7 +394,7 @@ public:
     }
 
     base_uint&
-    operator&=(base_uint const& b)
+    operator&=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] &= b.data_[i];
@@ -404,7 +403,7 @@ public:
     }
 
     base_uint&
-    operator|=(base_uint const& b)
+    operator|=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] |= b.data_[i];
@@ -427,11 +426,11 @@ public:
         return *this;
     }
 
-    base_uint const
+    const base_uint
     operator++(int)
     {
         // postfix operator
-        base_uint const ret = *this;
+        const base_uint ret = *this;
         ++(*this);
 
         return ret;
@@ -453,11 +452,11 @@ public:
         return *this;
     }
 
-    base_uint const
+    const base_uint
     operator--(int)
     {
         // postfix operator
-        base_uint const ret = *this;
+        const base_uint ret = *this;
         --(*this);
 
         return ret;
@@ -478,7 +477,7 @@ public:
     }
 
     base_uint&
-    operator+=(base_uint const& b)
+    operator+=(const base_uint& b)
     {
         std::uint64_t carry = 0;
 
@@ -523,7 +522,7 @@ public:
     }
 
     [[nodiscard]] constexpr bool
-    parseHex(char const* str)
+    parseHex(const char* str)
     {
         return parseHex(std::string_view{str});
     }

include/xrpl/basics/chrono.h

@@ -20,16 +20,17 @@
 #ifndef RIPPLE_BASICS_CHRONO_H_INCLUDED
 #define RIPPLE_BASICS_CHRONO_H_INCLUDED
 
+#include <date/date.h>
+
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/clock/basic_seconds_clock.h>
 #include <xrpl/beast/clock/manual_clock.h>
 
-#include <date/date.h>
-
 #include <chrono>
 #include <cstdint>
 #include <ratio>
 #include <string>
+#include <type_traits>
 
 namespace ripple {
 

include/xrpl/basics/comparators.h

@@ -43,7 +43,7 @@ struct less
     using result_type = bool;
 
     constexpr bool
-    operator()(T const& left, T const& right) const
+    operator()(const T& left, const T& right) const
     {
         return std::less<T>()(left, right);
     }
@@ -55,7 +55,7 @@ struct equal_to
     using result_type = bool;
 
     constexpr bool
-    operator()(T const& left, T const& right) const
+    operator()(const T& left, const T& right) const
     {
         return std::equal_to<T>()(left, right);
     }

include/xrpl/basics/contract.h

@@ -21,9 +21,9 @@
 #define RIPPLE_BASICS_CONTRACT_H_INCLUDED
 
 #include <xrpl/beast/type_name.h>
-
 #include <exception>
 #include <string>
+#include <typeinfo>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/hardened_hash.h

@@ -24,8 +24,12 @@
 #include <xrpl/beast/hash/xxhasher.h>
 
 #include <cstdint>
+#include <functional>
 #include <mutex>
 #include <random>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/make_SSLContext.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_MAKE_SSLCONTEXT_H_INCLUDED
 
 #include <boost/asio/ssl/context.hpp>
-
 #include <string>
 
 namespace ripple {

include/xrpl/basics/mulDiv.h

@@ -23,6 +23,7 @@
 #include <cstdint>
 #include <limits>
 #include <optional>
+#include <utility>
 
 namespace ripple {
 auto constexpr muldiv_max = std::numeric_limits<std::uint64_t>::max();

include/xrpl/basics/partitioned_unordered_map.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <functional>
 #include <optional>
 #include <string>
@@ -52,7 +51,7 @@ template <
     typename Value,
     typename Hash,
     typename Pred = std::equal_to<Key>,
-    typename Alloc = std::allocator<std::pair<Key const, Value>>>
+    typename Alloc = std::allocator<std::pair<const Key, Value>>>
 class partitioned_unordered_map
 {
     std::size_t partitions_;

include/xrpl/basics/random.h

@@ -22,9 +22,9 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/beast/xor_shift_engine.h>
-
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <limits>
 #include <mutex>
 #include <random>

include/xrpl/basics/spinlock.h

@@ -19,7 +19,6 @@
 #define RIPPLE_BASICS_SPINLOCK_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <atomic>
 #include <limits>
 #include <type_traits>

include/xrpl/basics/tagged_integer.h

@@ -21,11 +21,11 @@
 #define BEAST_UTILITY_TAGGED_INTEGER_H_INCLUDED
 
 #include <xrpl/beast/hash/hash_append.h>
-
 #include <boost/operators.hpp>
-
+#include <functional>
 #include <iostream>
 #include <type_traits>
+#include <utility>
 
 namespace ripple {
 
@@ -74,13 +74,13 @@ public:
     }
 
     bool
-    operator<(tagged_integer const& rhs) const noexcept
+    operator<(const tagged_integer& rhs) const noexcept
     {
         return m_value < rhs.m_value;
     }
 
     bool
-    operator==(tagged_integer const& rhs) const noexcept
+    operator==(const tagged_integer& rhs) const noexcept
     {
         return m_value == rhs.m_value;
     }
@@ -142,14 +142,14 @@ public:
     }
 
     tagged_integer&
-    operator<<=(tagged_integer const& rhs) noexcept
+    operator<<=(const tagged_integer& rhs) noexcept
     {
         m_value <<= rhs.m_value;
         return *this;
     }
 
     tagged_integer&
-    operator>>=(tagged_integer const& rhs) noexcept
+    operator>>=(const tagged_integer& rhs) noexcept
     {
         m_value >>= rhs.m_value;
         return *this;

include/xrpl/beast/asio/io_latency_probe.h

@@ -21,7 +21,6 @@
 #define BEAST_ASIO_IO_LATENCY_PROBE_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/asio/basic_waitable_timer.hpp>
 #include <boost/asio/io_service.hpp>
 

include/xrpl/beast/clock/abstract_clock.h

@@ -20,6 +20,9 @@
 #ifndef BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 #define BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 
+#include <chrono>
+#include <string>
+
 namespace beast {
 
 /** Abstract interface to a clock.

include/xrpl/beast/clock/manual_clock.h

@@ -23,8 +23,6 @@
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <chrono>
-
 namespace beast {
 
 /** Manual clock implementation.

include/xrpl/beast/container/aged_container_utility.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/beast/container/aged_container.h>
 
-#include <chrono>
 #include <type_traits>
 
 namespace beast {

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

@@ -20,6 +20,8 @@
 #ifndef BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 #define BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 
+#include <type_traits>
+
 namespace beast {
 namespace detail {
 

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

@@ -25,14 +25,13 @@
 #include <xrpl/beast/container/detail/aged_associative_container.h>
 #include <xrpl/beast/container/detail/aged_container_iterator.h>
 #include <xrpl/beast/container/detail/empty_base_optimization.h>
-
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/set.hpp>
 #include <boost/version.hpp>
-
 #include <algorithm>
 #include <functional>
 #include <initializer_list>
+#include <iterator>
 #include <memory>
 #include <type_traits>
 #include <utility>

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

@@ -25,10 +25,8 @@
 #include <xrpl/beast/container/detail/aged_associative_container.h>
 #include <xrpl/beast/container/detail/aged_container_iterator.h>
 #include <xrpl/beast/container/detail/empty_base_optimization.h>
-
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/unordered_set.hpp>
-
 #include <algorithm>
 #include <cmath>
 #include <functional>

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

@@ -11,7 +11,6 @@
 #define BEAST_CONTAINER_DETAIL_EMPTY_BASE_OPTIMIZATION_H_INCLUDED
 
 #include <boost/type_traits/is_final.hpp>
-
 #include <type_traits>
 #include <utility>
 

include/xrpl/beast/core/LexicalCast.h

@@ -23,15 +23,16 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <boost/core/detail/string_view.hpp>
-
 #include <algorithm>
 #include <cerrno>
 #include <charconv>
 #include <cstdlib>
 #include <iterator>
+#include <limits>
 #include <string>
 #include <type_traits>
 #include <typeinfo>
+#include <utility>
 
 namespace beast {
 

include/xrpl/beast/core/List.h

@@ -21,6 +21,7 @@
 #define BEAST_INTRUSIVE_LIST_H_INCLUDED
 
 #include <iterator>
+#include <type_traits>
 
 namespace beast {
 

include/xrpl/beast/hash/hash_append.h

@@ -23,37 +23,14 @@
 
 #include <boost/container/flat_set.hpp>
 #include <boost/endian/conversion.hpp>
-
-/*
-
-Workaround for overzealous clang warning, which trips on libstdc++ headers
-
-  In file included from
-  /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/stl_algo.h:61:
-  /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/stl_tempbuf.h:263:8:
-  error: 'get_temporary_buffer<std::pair<ripple::Quality, const
-  std::vector<std::unique_ptr<ripple::Step>> *>>' is deprecated
-  [-Werror,-Wdeprecated-declarations] 263 |
-  std::get_temporary_buffer<value_type>(_M_original_len));
-       ^
-*/
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <functional>
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
 #include <array>
 #include <chrono>
+#include <cstdint>
 #include <cstring>
+#include <functional>
+#include <map>
 #include <memory>
+#include <set>
 #include <string>
 #include <system_error>
 #include <tuple>

include/xrpl/beast/hash/uhash.h

@@ -30,7 +30,7 @@ namespace beast {
 template <class Hasher = xxhasher>
 struct uhash
 {
-    uhash() = default;
+    explicit uhash() = default;
 
     using result_type = typename Hasher::result_type;
 

include/xrpl/beast/hash/xxhasher.h

@@ -21,7 +21,6 @@
 #define BEAST_HASH_XXHASHER_H_INCLUDED
 
 #include <boost/endian/conversion.hpp>
-
 #include <xxhash.h>
 
 #include <cstddef>

include/xrpl/beast/insight/Meter.h

@@ -20,10 +20,10 @@
 #ifndef BEAST_INSIGHT_METER_H_INCLUDED
 #define BEAST_INSIGHT_METER_H_INCLUDED
 
-#include <xrpl/beast/insight/MeterImpl.h>
-
 #include <memory>
 
+#include <xrpl/beast/insight/MeterImpl.h>
+
 namespace beast {
 namespace insight {