feat(consensus): record entropy contributors

Revert the local entropyFailed selector override introduced during sidecar reconciliation excision. ConsensusEntropy injection is ledger-defining, so accepted entropy roots remain authoritative; nodes without an accepted root still fall back through the normal missing-root path.

Update CSF parity, the focused onPreBuild regression, and the design intent note to capture that local timeout/diagnostic state must not override an accepted root.

.codecov.yml

@@ -1,6 +1,37 @@
+codecov:
+  require_ci_to_pass: true
+
+comment:
+  behavior: default
+  layout: reach,diff,flags,tree,reach
+  show_carryforward_flags: false
+
 coverage:
+  range: "60..80"
+  precision: 1
+  round: nearest
   status:
     project:
       default:
         target: 60%
         threshold: 2%
+    patch:
+      default:
+        target: auto
+        threshold: 2%
+    changes: false
+
+github_checks:
+  annotations: true
+
+parsers:
+  cobertura:
+    partials_as_hits: true
+    handle_missing_conditions : true
+
+slack_app: false
+
+ignore:
+  - "src/test/"
+  - "include/xrpl/beast/test/"
+  - "include/xrpl/beast/unit_test/"

.git-blame-ignore-revs

@@ -1,8 +1,25 @@
 # This feature requires Git >= 2.24
 # To use it by default in git blame:
 # git config blame.ignoreRevsFile .git-blame-ignore-revs
+# Format first-party source according to .clang-format
 50760c693510894ca368e90369b0cc2dabfd07f3
-e2384885f5f630c8f0ffe4bf21a169b433a16858
-241b9ddde9e11beb7480600fd5ed90e1ef109b21
-760f16f56835663d9286bd29294d074de26a7ba6
-0eebe6a5f4246fced516d52b83ec4e7f47373edd
+# Reintroduce Clang-Format & Levelization
+da1d20d6d5d862716125d60899b80fab5302954a
+# Consolidate external libraries
+da1d20d6d5d862716125d60899b80fab5302954a
+# Rename .hpp to .h
+0345a2645d0f5ad900f4fbbcaff96040d3a887fc
+# Format formerly .hpp files
+5a227dc719016e10045e17c9396ad401118044f1
+# Rewrite includes
+e61880699997398f5a746e6c4034edc7632661f5
+# Move CMake directory (#4997)
+e47b1c1b3b97c3f6d11858ee02f463596e29e7f0
+# Rearrange sources (#4997)
+bfafa2bb39e562901736d656806bd700c3699a2f
+# Rewrite includes (#4997)
+e61880699997398f5a746e6c4034edc7632661f5
+# Recompute loops (#4997)
+d25b5dcd568bb96c18e347d55fac10fe901a1bfb
+# Reformat code with clang-format-18
+02749feea88ce61c1f7eeb2d61a57d8ecf07ab11

.gitattributes

@@ -11,6 +11,3 @@ LICENSE binary
 *.vcxproj   text eol=crlf
 *.props     text eol=crlf
 *.filters   text eol=crlf
-
-# Mark it as generated and folded out by default
-src/test/app/SetJSHook_wasm.h linguist-generated=true

.github/workflows/check-genesis-hooks.yml

@@ -40,7 +40,7 @@ jobs:
         run: |
           # Download install.sh
           curl -o /tmp/wasienv-install.sh https://raw.githubusercontent.com/wasienv/wasienv/master/install.sh
-          
+
           # Replace /bin to /local/bin
           sed -i 's|/bin|/local/bin|g' /tmp/wasienv-install.sh
 

.github/workflows/clang-format.yml

@@ -20,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 -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -not -path "src/quickjs/*" -exec clang-format-${CLANG_VERSION} -i {} +
+      run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
     - name: Check for differences
       id: assert
       run: |

.github/workflows/verify-generated-headers.yml

@@ -16,6 +16,8 @@ jobs:
             generator: ./hook/generate_extern.sh
           - target: hook/sfcodes.h
             generator: bash ./hook/generate_sfcodes.sh
+          - target: hook/genesis/headers/sfcodes.h
+            generator: bash ./hook/generate_sfcodes.sh
           - target: hook/tts.h
             generator: ./hook/generate_tts.sh
           - target: hook/ls_flags.h

.gitignore

@@ -124,10 +124,15 @@ pkg
 CMakeUserPresets.json
 bld.rippled/
 
-# binary
-qjsc
 generated
 .vscode
 
+# AI docs (local working documents)
+.ai-docs/
+
+# Local formal-methods workspace; kept as a separate repository and optionally
+# symlinked here for navigation.
+formal/lean/xahau_consensus
+
 # Suggested in-tree build directory
 /.build/

.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,29 @@
+"""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
+"""
+
+from helpers import CONSENSUS_ENTROPY_FEATURE
+
+
+async def scenario(ctx, log):
+    await ctx.wait_for_ledger_close()
+    ctx.feature(CONSENSUS_ENTROPY_FEATURE, vetoed=False, exclude_nodes=[4])
+
+    log("Waiting for ConsensusEntropy to be voted for...")
+    await ctx.wait_for_feature(
+        CONSENSUS_ENTROPY_FEATURE,
+        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/fallback_without_unl_report.py

@@ -0,0 +1,28 @@
+""":descr: healthy non-standalone testnet without UNLReport mints Tier 1 fallback"""
+
+from __future__ import annotations
+
+from helpers import require_entropy, get_entropy_tx, assert_consensus_fallback
+
+
+async def scenario(ctx, log):
+    await require_entropy(ctx, log)
+
+    # Non-standalone nodes require a ledger-anchored UNLReport before assigning
+    # validator_quorum / participant_aligned labels. Without it, the RNG pipeline
+    # may still collect commits/reveals, but injection must remain Tier 1.
+    await ctx.wait_for_ledgers(3, node_id=0, timeout=60)
+    log("Pipeline warmed up without UNLReport")
+
+    start_seq = ctx.validated_ledger_index(0)
+    await ctx.wait_for_ledgers(5, node_id=0, timeout=90)
+    end_seq = ctx.validated_ledger_index(0)
+    log(f"Inspecting ledgers {start_seq + 1} -> {end_seq}")
+
+    for seq in range(start_seq + 1, end_seq + 1):
+        ce, _ = get_entropy_tx(ctx, seq)
+        digest, count = assert_consensus_fallback(ce, seq)
+        log(f"  Ledger {seq}: EntropyCount={count} Digest={digest[:16]}...")
+
+    log(f"Verified {end_seq - start_seq} ledgers: all consensus_fallback")
+    log("PASS")

.testnet/scenarios/entropy/participant_aligned_smoke.py

@@ -0,0 +1,162 @@
+""":descr: 5/6 validator_quorum, 4/6 participant_aligned (tier 2), recovery
+
+Requires node_count: 6 (see suite.yml) — the smallest NON-degenerate Tier 2
+size. At n=6: tier2 floor = 4, validator quorum = 5, validation quorum = 5. So
+  6/6, 5/6 present -> validator_quorum  (EntropyTier=3)
+  4/6 present      -> participant_aligned (EntropyTier=2, count 4)   <-- the band
+  3/6 present      -> consensus_fallback (EntropyTier=1)
+n=5 has NO tier-2 band (tier2 == quorum == 4), which is why the existing
+degradation smoke at 5 nodes only ever sees tier 3 / fallback.
+
+KEY: the 4/6 window is BELOW the 80% validation quorum (5). The 4 survivors
+keep CLOSING ledgers that carry tier-2 entropy, but those ledgers do NOT
+validate until the network recovers — exactly the transition window Tier 2
+serves. So validated_ledger_index() stalls; we instead inspect a surviving
+node's CLOSED ledger (its LCL) directly, and cross-check the injection from the
+cohort's logs.
+"""
+
+from __future__ import annotations
+
+from helpers import (
+    require_entropy,
+    get_entropy_tx,
+    assert_participant_aligned,
+    assert_validator_quorum,
+)
+
+
+def _closed_entropy(result):
+    """(seq, ConsensusEntropy tx) from a ctx.ledger('closed', transactions=True)
+    result, or (None, None) if the fetch returned no usable ledger.
+
+    Enforces the per-ledger invariant that an entropy-enabled closed ledger
+    carries EXACTLY ONE ConsensusEntropy pseudo-tx (mirroring get_entropy_tx):
+    a duplicate or missing injection raises here with a clear error instead of
+    being silently skipped and resurfacing later as a generic 'no tier-2 ledger'.
+    """
+    if not result or not isinstance(result.get("ledger"), dict):
+        return None, None
+    led = result["ledger"]
+    try:
+        seq = int(led.get("ledger_index"))
+    except (TypeError, ValueError):
+        return None, None
+    ce = [
+        t
+        for t in led.get("transactions", [])
+        if isinstance(t, dict) and t.get("TransactionType") == "ConsensusEntropy"
+    ]
+    if len(ce) != 1:
+        raise AssertionError(
+            f"Closed ledger {seq}: expected 1 ConsensusEntropy txn, got {len(ce)}"
+        )
+    return seq, ce[0]
+
+
+async def scenario(ctx, log):
+    await require_entropy(ctx, log)
+
+    # Baseline: healthy 6/6 produces validator_quorum entropy.
+    await ctx.wait_for_ledgers(1, node_id=0, timeout=30)
+
+    # --- 5/6: settles back to validator_quorum (5 present >= quorum 5) ---
+    val_before_drop = ctx.validated_ledger_index(0)
+    ctx.stop_node(5)
+    await ctx.wait_for_nodes_down(nodes=[5], timeout=30)
+    # Settle a few ledgers past the membership change. The ledger right at a
+    # validator drop can carry a transient consensus_fallback (tier 1, count 0,
+    # deterministic and by design) before the commit/reveal pipeline re-primes,
+    # so we do NOT assume any single post-drop ledger is already tier 3.
+    await ctx.wait_for_ledgers(4, node_id=0, timeout=90)
+
+    # 5/6 is at/above the 80% quorum (5), so steady state is validator_quorum.
+    # Scan the post-drop validated ledgers (all carry the 5-node cohort, so a
+    # tier-3 here has count == 5) and require at least one clean validator_quorum
+    # — EntropyTier=3, count >= quorum, non-zero digest — tolerating the
+    # transition fallback instead of depending on where the tip happened to land.
+    val_5of6 = ctx.validated_ledger_index(0)
+    t3_seq = None
+    for seq in range(val_5of6, val_before_drop, -1):
+        ce, _ = get_entropy_tx(ctx, seq)
+        tier = ce.get("EntropyTier")
+        log(f"  5/6 ledger {seq}: tier={tier} count={ce.get('EntropyCount')}")
+        if tier == 3:
+            assert_validator_quorum(ce, seq, min_count=5)
+            t3_seq = seq
+            break
+    if t3_seq is None:
+        raise AssertionError(
+            f"5/6: no validator_quorum (tier 3) entropy in post-drop validated "
+            f"ledgers {val_before_drop + 1}..{val_5of6}"
+        )
+    log(f"5/6: validator_quorum at validated seq {t3_seq}")
+
+    #@@start test-participant-aligned-window
+    # --- 4/6: participant_aligned (Tier 2) degraded window ---
+    ctx.stop_node(4)
+    await ctx.wait_for_nodes_down(nodes=[4], timeout=30)
+
+    # ~12s window: confirm tier-2 INJECTION from the cohort's logs, and that the
+    # round is NOT the below-quorum fallback path (which is what distinguishes
+    # the tier-2 band from the tier-1 fallback regime).
+    op = await ctx.sleep(12, name="tier2_window")
+    selected_t2 = ctx.search_logs(
+        r"RNG: entropy selected seq=\d+ tier=2 count=4",
+        within=op.window,
+        nodes=[0, 1, 2, 3],
+    )
+    log(f"4/6: 'entropy selected tier=2 count=4' logs: {selected_t2.count}")
+    if selected_t2.count == 0:
+        raise AssertionError(
+            "4/6 window injected no participant_aligned (tier 2) entropy: no "
+            "'RNG: entropy selected ... tier=2 count=4' on the surviving cohort"
+        )
+    ctx.assert_not_log(
+        r"STALLDIAG: rng-commit-timeout-below-quorum",
+        within=op.window,
+        nodes=[0, 1, 2, 3],
+    )
+
+    # Verify the on-ledger EntropyTier=2 DIRECTLY: validation is stalled (4 < 5),
+    # so sample the surviving cohort's CLOSED ledger (its LCL — built but not yet
+    # validated). At least one must be participant_aligned with EntropyCount=4.
+    tier2_on_ledger = 0
+    last_seq = None
+    for _ in range(5):
+        seq, ce = _closed_entropy(
+            ctx.ledger("closed", transactions=True, node_id=0)
+        )
+        if ce is not None and seq is not None and seq != last_seq:
+            last_seq = seq
+            tier = ce.get("EntropyTier")
+            count = ce.get("EntropyCount", -1)
+            log(f"  closed ledger {seq}: tier={tier} count={count}")
+            if tier == 2:
+                assert_participant_aligned(ce, seq, expected_count=4)
+                tier2_on_ledger += 1
+        await ctx.sleep(3)
+
+    if tier2_on_ledger == 0:
+        raise AssertionError(
+            "no closed participant_aligned (tier 2) ledger observed during the "
+            "4/6 window (tier 2 was injected per logs, but not seen on a closed "
+            "ledger)"
+        )
+    log(f"4/6: {tier2_on_ledger} participant_aligned closed ledger(s) verified")
+    #@@end test-participant-aligned-window
+
+    # --- Recovery: liveness — validation resumes once quorum is restored ---
+    ctx.start_node(4)
+    ctx.start_node(5)
+    await ctx.wait_for_ledgers(1, node_id=0, timeout=120)
+
+    val_recovered = ctx.validated_ledger_index(0)
+    if not val_recovered or val_recovered <= val_5of6:
+        raise AssertionError(
+            f"Validated ledger did not advance after recovery "
+            f"({val_5of6} -> {val_recovered})"
+        )
+    log(f"Recovered: validated seq {val_5of6} -> {val_recovered}")
+
+    log("PASS")

.testnet/scenarios/entropy/quorum_degradation_smoke.py

@@ -0,0 +1,164 @@
+""":descr: 4/5 liveness, 3/5 fail-closed sub-quorum window, recovery"""
+
+from __future__ import annotations
+
+from helpers import (
+    require_entropy,
+    get_entropy_tx,
+    entropy_fields,
+    assert_consensus_fallback,
+)
+
+
+def _closed_entropy(result):
+    """Return (seq, ConsensusEntropy tx) from a closed-ledger RPC result.
+
+    The 3/5 window is below validation quorum, so validated-ledger history is
+    expected to stall. Sampling a surviving node's closed ledger catches any
+    local LCL that advanced despite the sub-quorum condition.
+    """
+    if not result or not isinstance(result.get("ledger"), dict):
+        return None, None
+    ledger = result["ledger"]
+    try:
+        seq = int(ledger.get("ledger_index"))
+    except (TypeError, ValueError):
+        return None, None
+    ce = [
+        tx
+        for tx in ledger.get("transactions", [])
+        if isinstance(tx, dict) and tx.get("TransactionType") == "ConsensusEntropy"
+    ]
+    if len(ce) != 1:
+        raise AssertionError(
+            f"Closed ledger {seq}: expected 1 ConsensusEntropy txn, got {len(ce)}"
+        )
+    return seq, ce[0]
+
+
+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}")
+
+    if val_after and val_before and val_after > val_before:
+        raise AssertionError(
+            f"3/5 sub-quorum window unexpectedly validated ledgers "
+            f"({val_before} -> {val_after})"
+        )
+
+    # If the surviving cohort exposes an advanced closed ledger despite being
+    # below validation quorum, it must fail closed to consensus_fallback. This
+    # keeps the entropy assertion live without pretending validated history
+    # should advance at 3/5.
+    degraded_fallback = 0
+    last_closed = None
+    for _ in range(5):
+        seq, ce = _closed_entropy(ctx.ledger("closed", transactions=True, node_id=0))
+        if seq and val_before and seq > val_before and seq != last_closed:
+            last_closed = seq
+            digest, count = assert_consensus_fallback(ce, seq)
+            degraded_fallback += 1
+            log(
+                f"  3/5 closed ledger {seq}: EntropyCount={count} "
+                f"Digest={digest[:16]}... FALLBACK"
+            )
+        await ctx.sleep(2)
+
+    log(f"3/5 closed-ledger fallback samples: {degraded_fallback}")
+
+    # Log checks tied to current transition mechanics:
+    # - commit-set SHAMap publication is the observable output of entering the
+    #   commit sidecar phase
+    # - ConvergingCommit transition is the gateway out of seq=0-only behavior
+    # - rng-commit-timeout-below-quorum is the degraded-window fallback path
+    ctx.log_level("LedgerConsensus", "trace")
+    ctx.log_level("ConsensusExtensions", "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: built commitSet SHAMap", 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}")
+
+    below_quorum = ctx.search_logs(
+        r"STALLDIAG: rng-commit-timeout-below-quorum",
+        within=op.window,
+        nodes=[0, 1, 2],
+    )
+    log(f"3/5: RNG commit timeout below quorum logs in 6s: {below_quorum.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, validator-tier entropy is expected
+    # again (transitional fallback ledgers are fine) and must be quorum-met.
+    fallback_count = 0
+    validator_count = 0
+    for seq in range(pre_recovery + 1, val_recovered + 1):
+        ce, _ = get_entropy_tx(ctx, seq)
+        digest, entropy_count, is_fallback = entropy_fields(ce)
+
+        if is_fallback:
+            fallback_count += 1
+        else:
+            validator_count += 1
+            if entropy_count < 4:
+                raise AssertionError(
+                    f"Ledger {seq}: validator entropy with sub-quorum "
+                    f"EntropyCount={entropy_count} (need >= 4)"
+                )
+
+        log(
+            f"  Ledger {seq}: EntropyCount={entropy_count} "
+            f"{'FALLBACK' if is_fallback else 'VALIDATOR'}"
+        )
+
+    log(
+        f"Entropy summary: {fallback_count} fallback, "
+        f"{validator_count} validator"
+    )
+
+    log("PASS")

.testnet/scenarios/entropy/quorum_recovery_smoke.py

@@ -0,0 +1,44 @@
+""":descr: drop 2 nodes (3/5 stall), restart both, verify recovery"""
+
+from __future__ import annotations
+
+from helpers import require_entropy
+
+
+async def scenario(ctx, log):
+    await require_entropy(ctx, log)
+
+    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 the RNG pipeline to warm up past initial proposal/sidecar gossip.
+    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,104 @@
+defaults:
+  network:
+    node_count: 5
+    launcher: tmux
+    find_ports: true
+    slave_delay: 0.2
+    features:
+      - ConsensusEntropy
+      - Export
+    track_features:
+      - ConsensusEntropy
+      - Export
+    unl_report: true
+    log_levels:
+      TxQ: info
+      Protocol: debug
+      Peer: debug
+      LedgerConsensus: debug
+      ConsensusExtensions: debug
+      NetworkOPs: info
+    env:
+      XAHAU_RESOURCE_PER_PORT: "1"
+    rc:
+      - 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:
+      rc:
+        - rng_poll_ms=333
+        - n3:no_export_sig=true
+        - n4:no_export_sig=true
+
+  - name: export_without_unl_report
+    script: .testnet/scenarios/export/export_without_unl_report.py
+    network:
+      features:
+        - Export
+      track_features:
+        - Export
+      unl_report: false
+
+  - name: export_no_veto_missing_observation
+    script: .testnet/scenarios/export/export_no_veto_missing_observation.py
+    network:
+      rc:
+        - rng_poll_ms=333
+        - n4:no_export_sig_hash=true
+
+  # CE + Export: 1 node suppressed, 4/5 = 80% quorum, should succeed
+  - name: export_ce_one_node_down
+    script: .testnet/scenarios/export/export_quorum.py
+    params:
+      expect_success: true
+    network:
+      rc:
+        - rng_poll_ms=333
+        - n4:no_export_sig=true
+
+  # --- Export only, no CE (80% active-view quorum) ---
+  - name: export_only_all_up
+    script: .testnet/scenarios/export/export_quorum.py
+    params:
+      expect_success: true
+    network:
+      features:
+        - Export
+      track_features:
+        - Export
+
+  - name: export_only_one_node_down
+    script: .testnet/scenarios/export/export_quorum.py
+    params:
+      expect_success: true
+    network:
+      features:
+        - Export
+      track_features:
+        - Export
+      rc:
+        - rng_poll_ms=333
+        - n4:no_export_sig=true
+
+  - name: export_only_two_nodes_down
+    script: .testnet/scenarios/export/export_quorum.py
+    params:
+      expect_success: false
+    network:
+      features:
+        - Export
+      track_features:
+        - Export
+      rc:
+        - rng_poll_ms=333
+        - n3:no_export_sig=true
+        - n4:no_export_sig=true

.testnet/scenarios/export/export_degradation.py

@@ -0,0 +1,127 @@
+""":descr: Submit ttEXPORT with 2 nodes suppressing export sigs, verify it
+retries via terRETRY_EXPORT until LLS expiry (insufficient signatures).
+
+Nodes 3 and 4 have runtime_config no_export_sig=true, 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 (
+    EXPORT_RETRY_LEDGER_WINDOW,
+    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 runtime_config no_export_sig=true (3/5 sigs, need 4)")
+
+    #@@start test-export-below-quorum-expiry
+    # --- Submit ttEXPORT (should retry then expire -- only 3/5 sigs) ---
+    export_start = ctx.mark("export-degradation-submit-start")
+    result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Export",
+            "LastLedgerSequence": current_seq + EXPORT_RETRY_LEDGER_WINDOW,
+            "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 + EXPORT_RETRY_LEDGER_WINDOW,
+                "Flags": 2147483648,
+                "SigningPubKey": "",
+            },
+        },
+        alice.wallet,
+        timeout=60,
+    )
+    export_end = ctx.mark("export-degradation-submit-end")
+
+    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 runtime_config no_export_sig"
+        )
+
+    # Should be tecEXPORT_EXPIRED (LLS reached without quorum). Be exact here:
+    # any other non-success means the retry/expiry boundary regressed.
+    if engine_result != "tecEXPORT_EXPIRED":
+        raise AssertionError(
+            f"Expected tecEXPORT_EXPIRED below quorum, got {engine_result}"
+        )
+
+    log(f"Export failed as expected ({engine_result})")
+
+    retry_logs = ctx.assert_log(
+        r"Export: insufficient signatures .*result=terRETRY_EXPORT",
+        since=export_start,
+        until=export_end,
+    )
+    log(f"Export insufficient-signature retries: {retry_logs.count}")
+
+    expired_logs = ctx.assert_log(
+        r"Export: last ledger expired .*result=tecEXPORT_EXPIRED",
+        since=export_start,
+        until=export_end,
+    )
+    log(f"Export LLS expiry logs: {expired_logs.count}")
+
+    # No shadow ticket should exist (export never reached quorum)
+    assert_shadow_ticket(ctx, alice.address, log, expect_exists=False)
+    #@@end test-export-below-quorum-expiry
+
+    # --- 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,246 @@
+"""Shared helpers for Export scenario tests."""
+
+from __future__ import annotations
+
+from xahaud_scripts.testnet.config import _unl_report_index, feature_name_to_hash
+
+EXPORT_RETRY_LEDGER_WINDOW = 5
+
+
+async def require_export(
+    ctx, log, *, require_unl_report=True, require_runtime_config=True
+):
+    """Wait for first ledger and assert Export is enabled.
+
+    Network-mode Export success requires a parent-ledger UNLReport-backed
+    active validator view. Most export scenarios seed that report in genesis;
+    assert it here so a success-path test cannot accidentally pass setup
+    without the condition Export::doApply requires. The no-UNLReport retry
+    scenario opts out deliberately.
+
+    The tracked export suite also uses XAHAUD_RUNTIME_TEST_CONFIG for polling
+    and fault-injection knobs. Default binaries reject the runtime_config RPC,
+    so check it up front rather than silently running without those knobs.
+    """
+    await ctx.wait_for_ledger_close(timeout=120)
+
+    if require_runtime_config:
+        result = ctx.rpc.runtime_config(0)
+        if not result or result.get("error"):
+            raise AssertionError(
+                "Export suite requires a binary built with "
+                "xahaud_runtime_test_config=ON; runtime_config RPC returned "
+                f"{result}"
+            )
+        log("RuntimeConfig RPC active")
+
+    feature = ctx.feature_check(feature_name_to_hash("Export"), node_id=0)
+    if not feature or not feature.get("enabled", False):
+        raise AssertionError(f"Export not enabled: {feature}")
+    log("Export enabled")
+
+    if require_unl_report:
+        result = ctx.rpc.ledger_entry(0, _unl_report_index())
+        node = (result or {}).get("node", {})
+        active = node.get("ActiveValidators", [])
+        if node.get("LedgerEntryType") != "UNLReport" or not active:
+            raise AssertionError(
+                "Export success scenario requires a ledger UNLReport with "
+                f"ActiveValidators, got: {result}"
+            )
+        log(f"UNLReport active validators: {len(active)}")
+
+
+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 find_export_signature_witness(ctx, seq, witness_hash):
+    """Find the same-ledger ExportSignatures witness by transaction hash."""
+    result = ctx.ledger(seq, transactions=True)
+    txns = (result or {}).get("ledger", {}).get("transactions", [])
+    for tx in txns:
+        if not isinstance(tx, dict):
+            continue
+        if tx.get("hash") != witness_hash:
+            continue
+        if tx.get("TransactionType") != "ExportSignatures":
+            raise AssertionError(
+                f"ExportSignatureHash {witness_hash} resolved to "
+                f"{tx.get('TransactionType')}, not ExportSignatures"
+            )
+        return tx
+    raise AssertionError(
+        f"ExportSignatures witness {witness_hash} not found in ledger {seq}"
+    )
+
+
+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, expected_exports=None
+):
+    """Assert hook executed with ACCEPT and expected emission counts.
+
+    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)
+    export_count = exec_entry.get("HookExportCount")
+    return_code = exec_entry.get("HookReturnCode", "")
+
+    log(
+        f"  HookResult={hook_result} EmitCount={emit_count} "
+        f"ExportCount={export_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}"
+        )
+
+    if expected_exports is not None and export_count != expected_exports:
+        raise AssertionError(
+            f"Expected {expected_exports} exports, got {export_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 _signer_entries(witness):
+    entries = []
+    for entry in witness.get("Signers", []):
+        signer = entry.get("Signer", entry)
+        entries.append(signer)
+    return entries
+
+
+def _account_sort_key(address):
+    from xrpl.core.addresscodec import decode_classic_address
+
+    return decode_classic_address(address)
+
+
+def assert_export_result(meta, log, *, ctx=None, require_signers=True):
+    """Assert ExportResult is present and well-formed in metadata.
+
+    Returns the ExportResult dict. When signers are required, the result is
+    annotated with _Witness and _WitnessSigners from the same-ledger
+    ttEXPORT_SIGNATURES pseudo transaction.
+    """
+    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")
+    if "ExportSignatureHash" not in export_result:
+        raise AssertionError("ExportResult missing ExportSignatureHash")
+
+    log(f"  ExportResult: seq={export_result['LedgerSequence']} "
+        f"hash={export_result['TransactionHash'][:16]}... "
+        f"witness={export_result['ExportSignatureHash'][:16]}...")
+
+    if "ExportedTxn" in export_result:
+        raise AssertionError(
+            "ExportResult should reference ExportSignatureHash, not embed "
+            "ExportedTxn"
+        )
+
+    if require_signers:
+        if ctx is None:
+            raise AssertionError(
+                "assert_export_result(require_signers=True) needs ctx to "
+                "dereference ExportSignatureHash"
+            )
+        witness = find_export_signature_witness(
+            ctx,
+            export_result["LedgerSequence"],
+            export_result["ExportSignatureHash"],
+        )
+        if witness.get("TransactionHash") != export_result["TransactionHash"]:
+            raise AssertionError(
+                "ExportSignatures witness TransactionHash does not match "
+                "ExportResult.TransactionHash"
+            )
+        if witness.get("LedgerSequence") != export_result["LedgerSequence"]:
+            raise AssertionError(
+                "ExportSignatures witness LedgerSequence does not match "
+                "ExportResult.LedgerSequence"
+            )
+        signers = _signer_entries(witness)
+        if not signers:
+            raise AssertionError("ExportSignatures witness has no Signers")
+        accounts = [s.get("Account") for s in signers]
+        if accounts != sorted(accounts, key=_account_sort_key):
+            raise AssertionError("ExportSignatures Signers are not Account-sorted")
+        log(f"  Witness signers: {len(signers)} validator(s)")
+        export_result["_Witness"] = witness
+        export_result["_WitnessSigners"] = signers
+
+    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_no_veto_missing_observation.py

@@ -0,0 +1,88 @@
+""":descr: Export succeeds when quorum sidecar material exists but one active
+validator withholds exportSigSetHash observation.
+
+Node 4 has runtime_config no_export_sig_hash=true. It still attaches export
+signatures, but it does not publish its exportSigSetHash in proposals. The
+remaining 4/5 active validators can still align on the same export sidecar
+hash, so the round must not retry/expire just because fullObservation is false.
+"""
+
+from __future__ import annotations
+
+from export_helpers import (
+    EXPORT_RETRY_LEDGER_WINDOW,
+    require_export,
+    assert_export_result,
+    assert_shadow_ticket,
+)
+
+
+async def scenario(ctx, log):
+    await require_export(ctx, log)
+
+    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("Node 4 withholds exportSigSetHash but still attaches export signatures")
+
+    export_start = ctx.mark("export-no-veto-submit-start")
+    result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Export",
+            "LastLedgerSequence": current_seq + EXPORT_RETRY_LEDGER_WINDOW,
+            "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 + EXPORT_RETRY_LEDGER_WINDOW,
+                "Flags": 2147483648,
+                "SigningPubKey": "",
+            },
+        },
+        alice.wallet,
+        timeout=60,
+    )
+    export_end = ctx.mark("export-no-veto-submit-end")
+
+    final_seq = ctx.validated_ledger_index(0)
+    engine_result = result.get("engine_result", "")
+    meta = result.get("meta", {})
+
+    log(f"Export completed at ledger {final_seq}, result: {engine_result}")
+    if engine_result != "tesSUCCESS":
+        raise AssertionError(f"Expected tesSUCCESS, got {engine_result}")
+
+    export_result = assert_export_result(meta, log, ctx=ctx, require_signers=True)
+    signers = export_result.get("_WitnessSigners", [])
+    if len(signers) < 4:
+        raise AssertionError(f"Expected at least 4 signers, got {len(signers)}")
+    log(f"Export signer count: {len(signers)}")
+
+    no_veto_logs = ctx.assert_log(
+        r"Export: missing exportSigSetHash observation ignored",
+        since=export_start,
+        until=export_end,
+    )
+    log(f"Export no-veto missing-observation logs: {no_veto_logs.count}")
+
+    withhold_logs = ctx.assert_log(
+        r"Export: withholding exportSigSetHash",
+        since=export_start,
+        until=export_end,
+    )
+    log(f"Export sidecar hash withholding logs: {withhold_logs.count}")
+
+    assert_shadow_ticket(ctx, alice.address, log, expect_exists=True)
+
+    log("PASS")

.testnet/scenarios/export/export_quorum.py

@@ -0,0 +1,118 @@
+""":descr: Test Export quorum behavior. When enough active validators sign,
+the export should succeed whether or not CE is enabled. When fewer than the
+active-view quorum sign, 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 (
+    EXPORT_RETRY_LEDGER_WINDOW,
+    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}")
+    outcome = "success" if expect_success else "failure (below quorum)"
+    log(f"Expecting export {outcome}")
+
+    # --- Submit ttEXPORT ---
+    result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Export",
+            "LastLedgerSequence": current_seq + EXPORT_RETRY_LEDGER_WINDOW,
+            "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 + EXPORT_RETRY_LEDGER_WINDOW,
+                "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, ctx=ctx, require_signers=True)
+
+        # Assert shadow ticket was created
+        assert_shadow_ticket(ctx, alice.address, log, expect_exists=True)
+
+        log("Export succeeded as expected (active-view quorum reached)")
+    else:
+        if engine_result == "tesSUCCESS":
+            raise AssertionError(
+                "Export should NOT have succeeded below active-view quorum"
+            )
+        if engine_result != "tecEXPORT_EXPIRED":
+            raise AssertionError(
+                "Expected tecEXPORT_EXPIRED below active-view quorum, "
+                f"got {engine_result}"
+            )
+        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/export_without_unl_report.py

@@ -0,0 +1,96 @@
+""":descr: Export retries/expires without a ledger-anchored UNLReport view.
+
+All validators may sign, but network-mode Export must not assemble quorum
+material from a node-local trusted-config view. Without UNLReport, the export
+should retry until LastLedgerSequence and expire without creating a shadow
+ticket.
+"""
+
+from __future__ import annotations
+
+from export_helpers import (
+    EXPORT_RETRY_LEDGER_WINDOW,
+    require_export,
+    assert_shadow_ticket,
+)
+
+
+async def scenario(ctx, log):
+    await require_export(ctx, log, require_unl_report=False)
+
+    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("UNLReport intentionally absent; export must not use local config view")
+
+    export_start = ctx.mark("export-without-unlreport-submit-start")
+    result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Export",
+            "LastLedgerSequence": current_seq + EXPORT_RETRY_LEDGER_WINDOW,
+            "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 + EXPORT_RETRY_LEDGER_WINDOW,
+                "Flags": 2147483648,
+                "SigningPubKey": "",
+            },
+        },
+        alice.wallet,
+        timeout=60,
+    )
+    export_end = ctx.mark("export-without-unlreport-submit-end")
+
+    final_seq = ctx.validated_ledger_index(0)
+    engine_result = result.get("engine_result", "")
+    log(f"Export completed at ledger {final_seq}, result: {engine_result}")
+
+    if engine_result == "tesSUCCESS":
+        raise AssertionError(
+            "Export should not succeed without a ledger-anchored UNLReport view"
+        )
+
+    # Be exact: without a UNLReport view the export should retry until LLS and
+    # expire, not fail by some unrelated terminal code.
+    if engine_result != "tecEXPORT_EXPIRED":
+        raise AssertionError(
+            "Expected tecEXPORT_EXPIRED without UNLReport view, "
+            f"got {engine_result}"
+        )
+
+    warning_logs = ctx.assert_log(
+        r"Export: retrying without ledger-anchored validator view",
+        since=export_start,
+        until=export_end,
+    )
+    log(f"Export no-UNLReport retry warnings: {warning_logs.count}")
+
+    retry_logs = ctx.assert_log(
+        r"Export: insufficient signatures .*result=terRETRY_EXPORT",
+        since=export_start,
+        until=export_end,
+    )
+    log(f"Export retry logs: {retry_logs.count}")
+
+    expired_logs = ctx.assert_log(
+        r"Export: last ledger expired .*result=tecEXPORT_EXPIRED",
+        since=export_start,
+        until=export_end,
+    )
+    log(f"Export expiry logs: {expired_logs.count}")
+
+    assert_shadow_ticket(ctx, alice.address, log, expect_exists=False)
+
+    log("PASS")

.testnet/scenarios/export/retriable_export.py

@@ -0,0 +1,99 @@
+""":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 (
+    EXPORT_RETRY_LEDGER_WINDOW,
+    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 + EXPORT_RETRY_LEDGER_WINDOW,
+            "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 + EXPORT_RETRY_LEDGER_WINDOW,
+                "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, ctx=ctx, 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,212 @@
+""":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}")
+
+    # xport() schedules a ttEXPORT through the emitted directory, but hook
+    # metadata reports it separately from ordinary HookEmissions.
+    trigger_meta = trigger_result.get("meta", {})
+    assert_hook_accepted(trigger_meta, log, expected_emits=0, expected_exports=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, ctx=ctx, 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,180 @@
+"""Shared helpers for ConsensusEntropy scenario tests."""
+
+from __future__ import annotations
+
+from xahaud_scripts.testnet.config import feature_name_to_hash
+
+ZERO_DIGEST = "0" * 64
+CONSENSUS_ENTROPY_FEATURE = feature_name_to_hash("ConsensusEntropy")
+
+
+def feature_hash(name: str) -> str:
+    """Return the amendment hash accepted by feature RPC."""
+    return feature_name_to_hash(name)
+
+
+def feature_status(ctx, name: str, node_id=0):
+    """Query a feature by amendment hash; feature RPC names are ambiguous."""
+    return ctx.feature_check(feature_hash(name), node_id=node_id)
+
+
+def consensus_entropy_feature(ctx, node_id=0):
+    """Query ConsensusEntropy by amendment hash."""
+    return feature_status(ctx, "ConsensusEntropy", node_id=node_id)
+
+
+async def require_entropy(ctx, log):
+    """Wait for first ledger and assert ConsensusEntropy is enabled."""
+    await ctx.wait_for_ledger_close(timeout=120)
+    feature = consensus_entropy_feature(ctx, 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")
+
+    ledger = result.get("ledger")
+    if not isinstance(ledger, dict):
+        raise AssertionError(f"Ledger {seq}: fetch returned no ledger: {result}")
+
+    txns = 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_fallback) from a ConsensusEntropy tx.
+
+    consensus_fallback rounds carry a deterministic non-zero consensus-bound
+    digest with EntropyCount=0 and EntropyTier=1 (consensus_fallback).
+    Validator entropy has EntropyTier=3 (validator_quorum).
+
+    WARNING: is_fallback is ``tier != 3``, so it lumps participant_aligned
+    (Tier 2) in with fallback. It is only safe where no Tier 2 band exists
+    (e.g. 5-node networks, where tier2 == quorum). For band-aware scenarios use
+    the explicit assert_consensus_fallback / assert_participant_aligned /
+    assert_validator_quorum helpers, which check EntropyTier directly.
+    """
+    digest = ce_tx.get("Digest", "")
+    entropy_count = ce_tx.get("EntropyCount", -1)
+    tier = ce_tx.get("EntropyTier", None)
+    if tier is not None:
+        is_fallback = tier != 3
+    else:
+        is_fallback = entropy_count == 0
+    return digest, entropy_count, is_fallback
+
+
+def assert_participant_aligned(ce_tx, seq, expected_count=None):
+    """Assert participant_aligned (Tier 2) entropy on a ConsensusEntropy tx.
+
+    Tier 2 is the sub-quorum band: the agreed reveal cohort is >= the
+    participant floor but < the 80% validator quorum, so it carries
+    EntropyTier=2 with a deterministic non-zero digest. NOTE entropy_fields()'s
+    is_fallback lumps tier 2 in with fallback (is_fallback = tier != 3), so the
+    tier must be checked EXPLICITLY here.
+    """
+    digest = ce_tx.get("Digest", "")
+    count = ce_tx.get("EntropyCount", -1)
+    tier = ce_tx.get("EntropyTier", None)
+    if tier != 2:
+        raise AssertionError(
+            f"Ledger {seq}: expected EntropyTier==2 (participant_aligned), "
+            f"got {tier} (EntropyCount={count})"
+        )
+    if not digest or digest == ZERO_DIGEST:
+        raise AssertionError(
+            f"Ledger {seq}: participant_aligned digest must be non-zero, got "
+            f"{digest[:16]}..."
+        )
+    if expected_count is not None and count != expected_count:
+        raise AssertionError(
+            f"Ledger {seq}: participant_aligned EntropyCount must be "
+            f"{expected_count} (the surviving cohort), got {count}"
+        )
+    return digest, count
+
+
+def assert_validator_quorum(ce_tx, seq, min_count=None):
+    """Assert validator_quorum (Tier 3) entropy on a ConsensusEntropy tx:
+    EntropyTier=3, a deterministic non-zero digest, and (optionally)
+    EntropyCount >= min_count (the active quorum). The count can EXCEED the
+    quorum (e.g. a still-full 6/6 ledger caught at a 6->5 transition), so check
+    >=, not ==.
+    """
+    digest = ce_tx.get("Digest", "")
+    count = ce_tx.get("EntropyCount", -1)
+    tier = ce_tx.get("EntropyTier", None)
+    if tier != 3:
+        raise AssertionError(
+            f"Ledger {seq}: expected EntropyTier==3 (validator_quorum), got "
+            f"{tier} (EntropyCount={count})"
+        )
+    if not digest or digest == ZERO_DIGEST:
+        raise AssertionError(
+            f"Ledger {seq}: validator_quorum digest must be non-zero, got "
+            f"{digest[:16]}..."
+        )
+    if min_count is not None and count < min_count:
+        raise AssertionError(
+            f"Ledger {seq}: validator_quorum EntropyCount={count} < quorum "
+            f"{min_count}"
+        )
+    return digest, count
+
+
+def assert_consensus_fallback(ce_tx, seq):
+    """Assert consensus_fallback (Tier 1) entropy on a ConsensusEntropy tx:
+    EntropyTier=1, EntropyCount=0, and a deterministic NON-zero digest.
+    """
+    digest = ce_tx.get("Digest", "")
+    count = ce_tx.get("EntropyCount", -1)
+    tier = ce_tx.get("EntropyTier", None)
+    if tier != 1:
+        raise AssertionError(
+            f"Ledger {seq}: expected EntropyTier==1 (consensus_fallback), got "
+            f"{tier} (EntropyCount={count})"
+        )
+    if count != 0:
+        raise AssertionError(
+            f"Ledger {seq}: consensus_fallback EntropyCount must be 0, got "
+            f"{count}"
+        )
+    if not digest or digest == ZERO_DIGEST:
+        raise AssertionError(
+            f"Ledger {seq}: consensus_fallback digest must be non-zero, got "
+            f"{digest[:16]}..."
+        )
+    return digest, count
+
+
+def assert_valid_entropy(ce_tx, seq, seen_digests=None):
+    """Assert quorum-met validator entropy. Optionally check uniqueness."""
+    digest, entropy_count, is_fallback = entropy_fields(ce_tx)
+
+    if is_fallback or not digest or digest == ZERO_DIGEST:
+        raise AssertionError(f"Ledger {seq}: fallback/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/latency-suite.yml

@@ -0,0 +1,92 @@
+defaults:
+  network:
+    node_count: 5
+    launcher: tmux
+    find_ports: true
+    slave_delay: 0.2
+    features:
+      - ConsensusEntropy
+      - Export
+    track_features:
+      - ConsensusEntropy
+      - Export
+    unl_report: true
+    log_levels:
+      TxQ: info
+      Protocol: debug
+      Peer: debug
+      LedgerConsensus: debug
+      ConsensusExtensions: debug
+      NetworkOPs: info
+    env:
+      XAHAU_RESOURCE_PER_PORT: "1"
+    rc:
+      - rng_poll_ms=250
+tests:
+  - name: latency_baseline_ce
+    script: .testnet/scenarios/perf/ce_export_latency_probe.py
+    params:
+      warmup_ledgers: 3
+      ledgers: 8
+      submit_export: false
+
+  - name: latency_baseline_export
+    script: .testnet/scenarios/perf/ce_export_latency_probe.py
+    params:
+      warmup_ledgers: 3
+      ledgers: 8
+      submit_export: true
+
+  - name: latency_proposal_delay_export
+    script: .testnet/scenarios/perf/ce_export_latency_probe.py
+    params:
+      warmup_ledgers: 3
+      ledgers: 8
+      submit_export: true
+    network:
+      rc:
+        - rng_poll_ms=250
+        - delay=100,jitter=25,msg=proposal
+
+  - name: latency_directed_pair_delay_export
+    script: .testnet/scenarios/perf/ce_export_latency_probe.py
+    params:
+      warmup_ledgers: 3
+      ledgers: 8
+      submit_export: true
+    network:
+      rc:
+        - rng_poll_ms=250
+        - n0->n2:delay=750,jitter=100,msg=proposal
+        - n2->n0:delay=750,jitter=100,msg=proposal
+
+  - name: latency_slow_minority_export
+    script: .testnet/scenarios/perf/ce_export_latency_probe.py
+    params:
+      warmup_ledgers: 3
+      ledgers: 8
+      submit_export: true
+      export_timeout: 120
+    network:
+      rc:
+        - rng_poll_ms=250
+        - n3->n0:delay=500,jitter=100,msg=proposal
+        - n3->n1:delay=500,jitter=100,msg=proposal
+        - n3->n2:delay=500,jitter=100,msg=proposal
+        - n4->n0:delay=500,jitter=100,msg=proposal
+        - n4->n1:delay=500,jitter=100,msg=proposal
+        - n4->n2:delay=500,jitter=100,msg=proposal
+        - n0->n3:delay=500,jitter=100,msg=proposal
+        - n1->n3:delay=500,jitter=100,msg=proposal
+        - n2->n3:delay=500,jitter=100,msg=proposal
+        - n0->n4:delay=500,jitter=100,msg=proposal
+        - n1->n4:delay=500,jitter=100,msg=proposal
+        - n2->n4:delay=500,jitter=100,msg=proposal
+
+  - name: latency_export_no_veto_with_delay
+    script: .testnet/scenarios/export/export_no_veto_missing_observation.py
+    network:
+      rc:
+        - rng_poll_ms=250
+        - delay=300,jitter=100,msg=proposal
+        - n4:no_export_sig_hash=true

.testnet/scenarios/perf/ce_export_latency_probe.py

@@ -0,0 +1,196 @@
+""":descr: measure CE/export behavior while RuntimeConfig injects latency/drop.
+
+The suite supplies runtime fault injection through network.rc. This scenario
+does not mutate RuntimeConfig itself; it observes what the launched network does
+under that condition and logs enough counters to compare variants.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+import json
+
+from export.export_helpers import assert_export_result, require_export
+from helpers import consensus_entropy_feature, get_entropy_tx
+
+
+async def _require_runtime_config(ctx, log):
+    result = ctx.rpc.runtime_config(0)
+    if not result or result.get("error"):
+        raise AssertionError(
+            "Latency probe requires a binary built with "
+            "xahaud_runtime_test_config=ON; runtime_config RPC returned "
+            f"{result}"
+        )
+    log("RuntimeConfig RPC active")
+
+
+async def _require_consensus_entropy(ctx, log):
+    feature = consensus_entropy_feature(ctx, node_id=0)
+    if not feature or not feature.get("enabled", False):
+        raise AssertionError(f"ConsensusEntropy not enabled: {feature}")
+    log("ConsensusEntropy enabled")
+
+
+def _log_runtime_config(ctx, log):
+    for node_id in range(ctx.node_count):
+        cfg = ctx.rpc.runtime_config(node_id)
+        if cfg is None:
+            raise AssertionError(f"runtime_config RPC failed on node {node_id}")
+        log(
+            f"runtime_config n{node_id}: "
+            f"{json.dumps(cfg, sort_keys=True, separators=(',', ':'))}"
+        )
+
+
+async def _submit_direct_export(ctx, log, *, timeout):
+    await ctx.fund_accounts({"alice": 10000, "bob": 1000})
+    alice = ctx.account("alice")
+    bob = ctx.account("bob")
+    current_seq = ctx.validated_ledger_index(0)
+
+    if current_seq is None:
+        raise AssertionError("validated ledger is not available before Export")
+
+    log(f"Submitting direct Export at validated ledger {current_seq}")
+    started = ctx.mark("latency-export-submit-start")
+    result = await ctx.submit_and_wait(
+        {
+            "TransactionType": "Export",
+            "LastLedgerSequence": current_seq + 12,
+            "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=timeout,
+    )
+    ended = ctx.mark("latency-export-submit-end")
+
+    elapsed = (ended.monotonic_ns - started.monotonic_ns) / 1_000_000_000
+    engine_result = result.get("engine_result", "")
+    log(f"Export result={engine_result} elapsed={elapsed:.3f}s")
+
+    if engine_result != "tesSUCCESS":
+        raise AssertionError(f"Expected Export tesSUCCESS, got {engine_result}")
+
+    export_result = assert_export_result(result.get("meta", {}), log)
+    signers = export_result.get("ExportedTxn", {}).get("Signers", [])
+    log(f"Export signer count={len(signers)}")
+    return started, ended
+
+
+def _summarize_logs(ctx, log, *, label, started, ended):
+    patterns = {
+        "rng_selected": r"RNG: entropy selected",
+        "rng_fallback": r"tier=1",
+        "rng_participant_aligned": r"tier=2",
+        "rng_validator_quorum": r"tier=3",
+        "export_retry": r"terRETRY_EXPORT",
+        "export_quorum_timeout": r"Export: exportSigSet quorum alignment timeout",
+        "export_missing_observation_ignored": (
+            r"Export: missing exportSigSetHash observation ignored"
+        ),
+    }
+    for name, pattern in patterns.items():
+        result = ctx.search_logs(pattern, since=started, until=ended, limit=500)
+        log(f"log_count {label}.{name}={result.count}")
+
+
+async def scenario(
+    ctx,
+    log,
+    *,
+    warmup_ledgers=3,
+    ledgers=8,
+    submit_export=False,
+    export_timeout=90,
+):
+    await ctx.wait_for_ledger_close(timeout=120)
+    await _require_runtime_config(ctx, log)
+    _log_runtime_config(ctx, log)
+    await _require_consensus_entropy(ctx, log)
+
+    if submit_export:
+        # require_export also asserts the UNLReport precondition for successful
+        # network-mode Export. Keep that explicit in perf runs so a missing
+        # report does not masquerade as a latency failure.
+        await require_export(ctx, log, require_runtime_config=False)
+
+    await ctx.wait_for_ledgers(warmup_ledgers, node_id=0, timeout=120)
+    warm_seq = ctx.validated_ledger_index(0)
+    log(f"Warmup complete at validated ledger {warm_seq}")
+
+    export_window = None
+    if submit_export:
+        export_window = await _submit_direct_export(
+            ctx, log, timeout=export_timeout
+        )
+
+    started = ctx.mark("latency-probe-start")
+    start_seq = ctx.validated_ledger_index(0)
+    await ctx.wait_for_ledgers(ledgers, node_id=0, timeout=max(120, ledgers * 30))
+    ended = ctx.mark("latency-probe-end")
+    end_seq = ctx.validated_ledger_index(0)
+
+    if start_seq is None or end_seq is None:
+        raise AssertionError("validated ledger index unavailable during probe")
+
+    elapsed = (ended.monotonic_ns - started.monotonic_ns) / 1_000_000_000
+    closed = max(0, end_seq - start_seq)
+    cadence = elapsed / closed if closed else 0.0
+    log(
+        f"Observed validated ledgers {start_seq + 1}..{end_seq} "
+        f"closed={closed} elapsed={elapsed:.3f}s cadence={cadence:.3f}s/ledger"
+    )
+
+    tiers: Counter[int] = Counter()
+    counts: Counter[int] = Counter()
+    missing_entropy = 0
+    for seq in range(start_seq + 1, end_seq + 1):
+        try:
+            ce, user_txns = get_entropy_tx(ctx, seq)
+        except AssertionError as exc:
+            missing_entropy += 1
+            log(f"  Ledger {seq}: no ConsensusEntropy tx ({exc})")
+            continue
+
+        tier = ce.get("EntropyTier", -1)
+        count = ce.get("EntropyCount", -1)
+        tiers[tier] += 1
+        counts[count] += 1
+        log(
+            f"  Ledger {seq}: tier={tier} count={count} "
+            f"user_txns={len(user_txns)} digest={ce.get('Digest', '')[:16]}..."
+        )
+
+    log(
+        "SUMMARY "
+        f"closed={closed} elapsed_s={elapsed:.3f} cadence_s={cadence:.3f} "
+        f"tiers={dict(sorted(tiers.items()))} "
+        f"counts={dict(sorted(counts.items()))} "
+        f"missing_entropy={missing_entropy}"
+    )
+
+    _summarize_logs(ctx, log, label="probe", started=started, ended=ended)
+    if export_window is not None:
+        _summarize_logs(
+            ctx,
+            log,
+            label="export",
+            started=export_window[0],
+            ended=export_window[1],
+        )
+
+    log("PASS")

.testnet/scenarios/suite.yml

@@ -0,0 +1,62 @@
+defaults:
+  network:
+    node_count: 5
+    launcher: tmux
+    find_ports: true
+    slave_delay: 0.2
+    features:
+      - ConsensusEntropy
+    track_features:
+      - ConsensusEntropy
+    unl_report: true
+    log_levels:
+      TxQ: info
+      Protocol: debug
+      Peer: debug
+      LedgerConsensus: debug
+      ConsensusExtensions: debug
+      NetworkOPs: info
+    env:
+      XAHAU_RESOURCE_PER_PORT: "1"
+    rc:
+      - rng_poll_ms=333
+
+tests:
+  - name: steady_state_entropy
+    script: .testnet/scenarios/entropy/steady_state_entropy.py
+
+  - name: fallback_without_unl_report
+    script: .testnet/scenarios/entropy/fallback_without_unl_report.py
+    network:
+      unl_report: false
+
+  - name: steady_state_entropy_fast_start
+    script: .testnet/scenarios/entropy/steady_state_entropy.py
+    network:
+      env:
+        XAHAUD_RUNTIME_TEST_CONFIG: '{"set":{"global":{"rng_poll_ms":333,"bootstrap_fast_start":true}}}'
+
+  - 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
+        ConsensusExtensions: trace
+
+  # Tier 2 (participant_aligned) needs 6 nodes: n=5 has no band (tier2 ==
+  # quorum). At 6, the 4/6 window is the participant_aligned band.
+  - name: participant_aligned_smoke
+    script: .testnet/scenarios/entropy/participant_aligned_smoke.py
+    network:
+      node_count: 6
+      log_levels:
+        LedgerConsensus: trace
+        ConsensusExtensions: trace
+
+  # Export scenarios: see export-suite.yml

Builds/levelization/results/loops.txt

@@ -26,7 +26,7 @@ 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.app > xrpld.peerfinder

Builds/levelization/results/ordering.txt

@@ -12,6 +12,7 @@ libxrpl.server > xrpl.basics
 libxrpl.server > xrpl.json
 libxrpl.server > xrpl.protocol
 libxrpl.server > xrpl.server
+test.app > test.shamap
 test.app > test.toplevel
 test.app > test.unit_test
 test.app > xrpl.basics
@@ -21,6 +22,7 @@ test.app > xrpld.ledger
 test.app > xrpld.nodestore
 test.app > xrpld.overlay
 test.app > xrpld.rpc
+test.app > xrpld.shamap
 test.app > xrpl.hook
 test.app > xrpl.json
 test.app > xrpl.protocol
@@ -43,6 +45,9 @@ test.consensus > xrpld.app
 test.consensus > xrpld.consensus
 test.consensus > xrpld.core
 test.consensus > xrpld.ledger
+test.consensus > xrpld.overlay
+test.consensus > xrpld.shamap
+test.consensus > xrpl.json
 test.consensus > xrpl.protocol
 test.core > test.jtx
 test.core > test.toplevel
@@ -84,6 +89,7 @@ test.nodestore > xrpl.basics
 test.nodestore > xrpld.core
 test.nodestore > xrpld.nodestore
 test.nodestore > xrpld.unity
+test.nodestore > xrpl.protocol
 test.overlay > test.jtx
 test.overlay > test.toplevel
 test.overlay > test.unit_test
@@ -118,6 +124,7 @@ test.rpc > xrpld.core
 test.rpc > xrpld.net
 test.rpc > xrpld.overlay
 test.rpc > xrpld.rpc
+test.rpc > xrpld.shamap
 test.rpc > xrpl.hook
 test.rpc > xrpl.json
 test.rpc > xrpl.protocol
@@ -150,7 +157,6 @@ xrpl.resource > xrpl.protocol
 xrpl.server > xrpl.basics
 xrpl.server > xrpl.json
 xrpl.server > xrpl.protocol
-xrpld.app > quickjs.toplevel
 xrpld.app > test.unit_test
 xrpld.app > xrpl.basics
 xrpld.app > xrpld.conditions

CMakeLists.txt

@@ -145,8 +145,6 @@ target_link_libraries(ripple_libs INTERFACE
   SQLite::SQLite3
 )
 
-include(deps/quickjs)
-
 if(coverage)
   include(RippledCov)
 endif()

README.md

@@ -2,7 +2,7 @@
 
 **Note:** Throughout this README, references to "we" or "our" pertain to the community and contributors involved in the Xahau network. It does not imply a legal entity or a specific collection of individuals.
 
-[Xahau](https://xahau.network/) is a decentralized cryptographic ledger that builds upon the robust foundation of the XRP Ledger. It inherits the XRP Ledger's Byzantine Fault Tolerant consensus algorithm and enhances it with additional features and functionalities. Developers and users familiar with the XRP Ledger will find that most documentation and tutorials available on [xrpl.org](https://xrpl.org) are relevant and applicable to Xahau, including those related to running validators and managing validator keys. For Xahau specific documentation you can visit our [documentation](https://xahau.network/)
+[Xahau](https://xahau.network/) is a decentralized cryptographic ledger that builds upon the robust foundation of the XRP Ledger. It inherits the XRP Ledger's Byzantine Fault Tolerant consensus algorithm under the normal XRPL assumptions about configured validator-list overlap, timing, and fault bounds, and enhances it with additional features and functionalities. Developers and users familiar with the XRP Ledger will find that most documentation and tutorials available on [xrpl.org](https://xrpl.org) are relevant and applicable to Xahau, including those related to running validators and managing validator keys. For Xahau specific documentation you can visit our [documentation](https://xahau.network/)
 
 ## XAH
 XAH is the public, counterparty-free asset native to Xahau and functions primarily as network gas. Transactions submitted to the Xahau network must supply an appropriate amount of XAH, to be burnt by the network as a fee, in order to be successfully included in a validated ledger. In addition, XAH also acts as a bridge currency within the Xahau DEX. XAH is traded on the open-market and is available for anyone to access. Xahau was created in 2023 with a supply of 600 million units of XAH.

build-core.sh

@@ -95,8 +95,16 @@ if [[ "$4" == "" ]]; then
   echo "Non GH, local building, no Action runner magic"
 else
   # GH Action, runner
-  cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
-  cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    if [[ "$(git rev-parse --abbrev-ref HEAD)" == "release" ]]; then
+        echo "building on the release branch... placing it in builds/candidate"
+        mkdir /data/builds/candidate
+        cp /io/release-build/xahaud /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+        cp /io/release-build/release.info /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    else
+        echo "building non-release branch, placing it in builds root"
+        cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+        cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    fi  
   echo "Published build to: http://build.xahau.tech/"
   echo $(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
 fi

build-full.sh

@@ -12,17 +12,16 @@ echo "-- GITHUB_REPOSITORY: $1"
 echo "-- GITHUB_SHA:        $2"
 echo "-- GITHUB_RUN_NUMBER: $4"
 
-umask 0000;
+umask 0000
 
 ####
 
-cd /io;
-mkdir -p src/certs;
-curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h;
-if [ "`grep certbundle.h src/xrpld/net/detail/RegisterSSLCerts.cpp | wc -l`" -eq "0" ]
-then
-    cp src/xrpld/net/detail/RegisterSSLCerts.cpp src/xrpld/net/detail/RegisterSSLCerts.cpp.old
-    perl -i -pe "s/^{/{
+cd /io
+mkdir -p src/certs
+curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h
+if [ "$(grep certbundle.h src/xrpld/net/detail/RegisterSSLCerts.cpp | wc -l)" -eq "0" ]; then
+  cp src/xrpld/net/detail/RegisterSSLCerts.cpp src/xrpld/net/detail/RegisterSSLCerts.cpp.old
+  perl -i -pe "s/^{/{
     #ifdef EMBEDDED_CA_BUNDLE
     BIO *cbio = BIO_new_mem_buf(ca_bundle.data(), ca_bundle.size());
     X509_STORE  *cts = SSL_CTX_get_cert_store(ctx.native_handle());
@@ -68,15 +67,14 @@ fi
 source /opt/rh/gcc-toolset-11/enable
 export PATH=/usr/local/bin:$PATH
 export CC='/usr/lib64/ccache/gcc' &&
-export CXX='/usr/lib64/ccache/g++' &&
-echo "-- Build Rippled --" &&
-pwd &&
+  export CXX='/usr/lib64/ccache/g++' &&
+  echo "-- Build Rippled --" &&
+  pwd &&
+  echo "MOVING TO [ build-core.sh ]"
 
-echo "MOVING TO [ build-core.sh ]";
-
-printenv > .env.temp;
-cat .env.temp | grep '=' | sed s/\\\(^[^=]\\+=\\\)/\\1\\\"/g|sed s/\$/\\\"/g > .env;
-rm .env.temp;
+printenv >.env.temp
+cat .env.temp | grep '=' | sed s/\\\(^[^=]\\+=\\\)/\\1\\\"/g | sed s/\$/\\\"/g >.env
+rm .env.temp
 
 echo "Persisting ENV:"
 cat .env

cfg/genesis.json

@@ -62,8 +62,7 @@
           "3C43D9A973AA4443EF3FC38E42DD306160FBFFDAB901CD8BAA15D09F2597EB87",
           "0285B7E5E08E1A8E4C15636F0591D87F73CB6A7B6452A932AD72BBC8E5D1CBE3",
           "6E739F4F8B07BED29FC9FF440DA3C301CD14A180DF45819F658FEC2F7DE31427",
-          "36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6",
-          "DD4F86291F142A20761B32B4D0CE4291F86CA33F0B46F0D04171482FBA52E536"
+          "36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6"
         ],
         "Flags": 0,
         "LedgerEntryType": "Amendments",

cfg/xahaud-standalone.cfg

@@ -1,4 +1,4 @@
-# standalone: ./xahaud -a --ledgerfile cfg/genesis.json --conf cfg/xahaud-standalone.cfg
+# standalone: ./xahaud -a --ledgerfile config/genesis.json --conf config/xahaud-standalone.cfg
 [server]
 port_rpc_admin_local
 port_ws_public
@@ -154,4 +154,3 @@ D686F2538F410C9D0D856788E98E3579595DAF7B38D38887F81ECAC934B06040 HooksUpdate1
 EDB4EE4C524E16BDD91D9A529332DED08DCAAA51CC6DC897ACFA1A0ED131C5B6 fix240819
 8063140E9260799D6716756B891CEC3E7006C4E4F277AB84670663A88F94B9C4 fixPageCap
 88693F108C3CD8A967F3F4253A32DEF5E35F9406ACD2A11B88B11D90865763A9 fix240911
-DD4F86291F142A20761B32B4D0CE4291F86CA33F0B46F0D04171482FBA52E536 JsHooks

cmake/CodeCoverage.cmake

@@ -95,6 +95,9 @@
 #     - replace both functions setup_target_for_coverage_gcovr_* with a single setup_target_for_coverage_gcovr
 #     - add support for all gcovr output formats
 #
+# 2024-04-03, Bronek Kozicki
+#     - add support for output formats: jacoco, clover, lcov
+#
 # USAGE:
 #
 # 1. Copy this file into your cmake modules path.
@@ -256,10 +259,10 @@ endif()
 #     BASE_DIRECTORY "../"                   # Base directory for report
 #                                            #  (defaults to PROJECT_SOURCE_DIR)
 #     FORMAT "cobertura"                     # Output format, one of:
-#                                            #  xml cobertura sonarqube json-summary
-#                                            #  json-details coveralls csv txt
-#                                            #  html-single html-nested html-details
-#                                            #  (xml is an alias to cobertura;
+#                                            #  xml cobertura sonarqube jacoco clover
+#                                            #  json-summary json-details coveralls csv
+#                                            #  txt html-single html-nested html-details
+#                                            #  lcov (xml is an alias to cobertura;
 #                                            #  if no format is set, defaults to xml)
 #     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
 #                                            #  to BASE_DIRECTORY, with CMake 3.4+)
@@ -308,6 +311,8 @@ function(setup_target_for_coverage_gcovr)
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
         elseif(Coverage_FORMAT STREQUAL "csv")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
+        elseif(Coverage_FORMAT STREQUAL "lcov")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
         else()
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
         endif()
@@ -320,6 +325,14 @@ function(setup_target_for_coverage_gcovr)
         set(Coverage_FORMAT cobertura) # overwrite xml
     elseif(Coverage_FORMAT STREQUAL "sonarqube")
         list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "jacoco")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty )
+    elseif(Coverage_FORMAT STREQUAL "clover")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty )
+    elseif(Coverage_FORMAT STREQUAL "lcov")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}" )
     elseif(Coverage_FORMAT STREQUAL "json-summary")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}" )
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)

cmake/RippledCore.cmake

@@ -58,7 +58,6 @@ target_link_libraries(xrpl.imports.main
     OpenSSL::Crypto
     Ripple::boost
     wasmedge::wasmedge
-    NIH::quickjs
     Ripple::opts
     Ripple::syslibs
     absl::random_random
@@ -166,6 +165,9 @@ if(xrpld)
   if(tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
   endif()
+  if(xahaud_runtime_test_config)
+    target_compile_definitions(rippled PUBLIC XAHAUD_ENABLE_RUNTIME_TEST_CONFIG=1)
+  endif()
   target_include_directories(rippled
     PRIVATE
       $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
@@ -181,6 +183,21 @@ if(xrpld)
       "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp"
     )
     target_sources(rippled PRIVATE ${sources})
+
+    set(HOOKS_TEST_DIR "" CACHE PATH "External hook Env-test directory")
+    if(NOT HOOKS_TEST_DIR AND DEFINED ENV{HOOKS_TEST_DIR})
+      set(HOOKS_TEST_DIR "$ENV{HOOKS_TEST_DIR}")
+    endif()
+    if(HOOKS_TEST_DIR)
+      file(GLOB_RECURSE hook_test_sources CONFIGURE_DEPENDS
+        "${HOOKS_TEST_DIR}/*_test.cpp"
+      )
+      if(hook_test_sources)
+        message(STATUS "Including external hook Env tests from ${HOOKS_TEST_DIR}")
+        target_sources(rippled PRIVATE ${hook_test_sources})
+        target_include_directories(rippled PRIVATE "${HOOKS_TEST_DIR}")
+      endif()
+    endif()
   endif()
 
   target_link_libraries(rippled

cmake/RippledInstall.cmake

@@ -6,7 +6,6 @@ include(create_symbolic_link)
 
 install (
   TARGETS
-    quickjs
     common
     opts
     ripple_syslibs

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/RippledSettings.cmake

@@ -12,6 +12,13 @@ option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
 
+option(xahaud_runtime_test_config
+  "Enable XAHAUD_RUNTIME_TEST_CONFIG env and runtime_config RPC fault-injection controls"
+  OFF)
+# Conan 2 local opt-in:
+# [conf]
+# tools.cmake.cmaketoolchain:extra_variables={"xahaud_runtime_test_config":"ON"}
+
 option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
 if(unity)
   if(NOT is_ci)

cmake/deps/quickjs.cmake

@@ -1,52 +0,0 @@
-# QuickJS source files
-set(QUICKJS_SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libutf.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/qsort_r.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/tutf8e.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/vector.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/char-utils.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/buffer-utils.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/utils.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/ringbuffer.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libregexp.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libregexp.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libunicode.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/cutils.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-libc.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libbf.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-textcode.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-internal.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/debug.c
-)
-
-# QuickJS include directories
-set(QUICKJS_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs)
-
-# RHTODO: Fix this to be dynamic
-set(QUICKJS_VERSION "2023-01-01")
-
-# QuickJS compile definitions
-set(QUICKJS_COMPILE_DEFINITIONS
-    _GNU_SOURCE
-    CONFIG_VERSION="${QUICKJS_VERSION}"
-    CONFIG_BIGNUM
-)
-
-# Create static library
-add_library(quickjs STATIC ${QUICKJS_SOURCES})
-target_include_directories(quickjs
-  PUBLIC
-    $<BUILD_INTERFACE:${QUICKJS_INCLUDE_DIRS}>
-    $<INSTALL_INTERFACE:include/quickjs>
-)
-target_compile_definitions(quickjs PUBLIC ${QUICKJS_COMPILE_DEFINITIONS})
-
-add_library(NIH::quickjs ALIAS quickjs)
-target_link_libraries(ripple_libs INTERFACE NIH::quickjs)
-
-install(
-    FILES
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/*.h
-    DESTINATION include/quickjs
-)

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

@@ -2,6 +2,9 @@
 // Generated using generate_extern.sh
 #include <stdint.h>
 #ifndef HOOK_EXTERN
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 extern int32_t __attribute__((noduplicate))
 _g(uint32_t guard_id, uint32_t maxiter);
@@ -336,5 +339,43 @@ 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);
+
+/*
+    Consensus entropy APIs.
+
+    min_tier is a fail-closed floor:
+      1 = consensus_fallback, 2 = participant_aligned, 3 = validator_quorum.
+    min_count is the minimum validator/reveal count the caller accepts.
+
+    If the most recent finalized entropy object does not satisfy both floors,
+    these APIs return TOO_LITTLE_ENTROPY. Open-ledger and simulate execution
+    are provisional previews over the entropy currently visible to the node;
+    final ordered ledger execution may see a different entropy object.
+*/
+extern int64_t
+dice(uint32_t sides, uint32_t min_tier, uint32_t min_count);
+
+extern int64_t
+random(
+    uint32_t write_ptr,
+    uint32_t write_len,
+    uint32_t min_tier,
+    uint32_t min_count);
+
+#ifdef __cplusplus
+}
+#endif
 #define HOOK_EXTERN
 #endif  // HOOK_EXTERN

hook/generate_error.sh

@@ -9,7 +9,7 @@ ENUM_FILE="$SCRIPT_DIR/../include/xrpl/hook/Enum.h"
 echo '// For documentation please see: https://xrpl-hooks.readme.io/reference/'
 echo '// Generated using generate_error.sh'
 echo '#ifndef HOOK_ERROR_CODES'
-sed -n '/enum hook_return_code/,/};/p' "$ENUM_FILE" |
+sed -n '/enum class hook_return_code/,/};/p' "$ENUM_FILE" |
     awk '
         function ltrim(s) { sub(/^[[:space:]]+/, "", s); return s }
         function rtrim(s) { sub(/[[:space:]]+$/, "", s); return s }
@@ -31,7 +31,7 @@ sed -n '/enum hook_return_code/,/};/p' "$ENUM_FILE" |
 
         {
             line = $0
-            if (line ~ /enum[[:space:]]+hook_return_code/)
+            if (line ~ /enum[[:space:]]+class[[:space:]]+hook_return_code/)
                 next
             if (line ~ /^[[:space:]]*\{/)
                 next

hook/generate_extern.sh

@@ -11,6 +11,9 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
     echo '// Generated using generate_extern.sh'
     echo '#include <stdint.h>'
     echo '#ifndef HOOK_EXTERN'
+    echo '#ifdef __cplusplus'
+    echo 'extern "C" {'
+    echo '#endif'
     echo
     awk '
         function trim(s) {
@@ -27,8 +30,8 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
                 next;
             }
             
-            # Look for comment lines that start with // int64_t or // int32_t
-            if (line ~ /^[[:space:]]*\/\/[[:space:]]*(int64_t|int32_t)[[:space:]]+[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*\(/) {
+            # Look for comment lines that start with // and contain function signature
+            if (line ~ /^[[:space:]]*\/\/[[:space:]]*[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]+[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*\(/) {
                 # Remove leading // and trim
                 sub(/^[[:space:]]*\/\/[[:space:]]*/, "", line);
                 line = trim(line);
@@ -38,6 +41,21 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
                     # Insert __attribute__((noduplicate)) before _g
                     sub(/[[:space:]]+_g/, " __attribute__((noduplicate)) _g", line);
                 }
+
+                if (line ~ /[[:space:]]+dice[[:space:]]*\(/) {
+                    print "/*";
+                    print "    Consensus entropy APIs.";
+                    print "";
+                    print "    min_tier is a fail-closed floor:";
+                    print "      1 = consensus_fallback, 2 = participant_aligned, 3 = validator_quorum.";
+                    print "    min_count is the minimum validator/reveal count the caller accepts.";
+                    print "";
+                    print "    If the most recent finalized entropy object does not satisfy both floors,";
+                    print "    these APIs return TOO_LITTLE_ENTROPY. Open-ledger and simulate execution";
+                    print "    are provisional previews over the entropy currently visible to the node;";
+                    print "    final ordered ledger execution may see a different entropy object.";
+                    print "*/";
+                }
                 
                 # printf("\n");
                 
@@ -46,6 +64,9 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
         }
     ' "$APPLY_HOOK"
 
+    echo '#ifdef __cplusplus'
+    echo '}'
+    echo '#endif'
     echo '#define HOOK_EXTERN'
     echo '#endif  // HOOK_EXTERN'
 } | (

hook/genesis/headers/hookapi.h

@@ -47,4 +47,4 @@
 #include "macro.h"
 #include "types.h"
 
-#endif
+#endif

hook/genesis/headers/macro.h

@@ -607,31 +607,37 @@ int out_len = 0;\
 #define PREPARE_PAYMENT_SIMPLE_SIZE 248U
 #endif
 
-#define PREPARE_PAYMENT_SIMPLE(buf_out_master, drops_amount_raw, to_address, dest_tag_raw, src_tag_raw)\
-    {\
-        uint8_t* buf_out = buf_out_master;\
-        uint8_t acc[20];\
-        uint64_t drops_amount = (drops_amount_raw);\
-        uint32_t dest_tag = (dest_tag_raw);\
-        uint32_t src_tag = (src_tag_raw);\
-        uint32_t cls = (uint32_t)ledger_seq();\
-        hook_account(SBUF(acc));\
-        _01_02_ENCODE_TT                   (buf_out, ttPAYMENT                      );      /* uint16  | size   3 */ \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );      /* uint32  | size   5 */ \
-        _02_03_ENCODE_TAG_SRC              (buf_out, src_tag                        );      /* uint32  | size   5 */ \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );      /* uint32  | size   5 */ \
-        _02_14_ENCODE_TAG_DST              (buf_out, dest_tag                       );      /* uint32  | size   5 */ \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );      /* uint32  | size   6 */ \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );      /* uint32  | size   6 */ \
-        _06_01_ENCODE_DROPS_AMOUNT         (buf_out, drops_amount                   );      /* amount  | size   9 */ \
-        uint8_t* fee_ptr = buf_out;\
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );      /* amount  | size   9 */ \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );      /* pk      | size  35 */ \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );      /* account | size  22 */ \
-        _08_03_ENCODE_ACCOUNT_DST          (buf_out, to_address                     );      /* account | size  22 */ \
-        int64_t edlen = etxn_details((uint32_t)buf_out, PREPARE_PAYMENT_SIMPLE_SIZE);       /* emitdet | size 1?? */ \
-        int64_t fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_SIZE);                                    \ 
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );                               \
+#define PREPARE_PAYMENT_SIMPLE(                                              \
+    buf_out_master, drops_amount_raw, to_address, dest_tag_raw, src_tag_raw) \
+    {                                                                        \
+        uint8_t* buf_out = buf_out_master;                                   \
+        uint8_t acc[20];                                                     \
+        uint64_t drops_amount = (drops_amount_raw);                          \
+        uint32_t dest_tag = (dest_tag_raw);                                  \
+        uint32_t src_tag = (src_tag_raw);                                    \
+        uint32_t cls = (uint32_t)ledger_seq();                               \
+        hook_account(SBUF(acc));                                             \
+        _01_02_ENCODE_TT(buf_out, ttPAYMENT);      /* uint16  | size   3 */  \
+        _02_02_ENCODE_FLAGS(buf_out, tfCANONICAL); /* uint32  | size   5 */  \
+        _02_03_ENCODE_TAG_SRC(buf_out, src_tag);   /* uint32  | size   5 */  \
+        _02_04_ENCODE_SEQUENCE(buf_out, 0);        /* uint32  | size   5 */  \
+        _02_14_ENCODE_TAG_DST(buf_out, dest_tag);  /* uint32  | size   5 */  \
+        _02_26_ENCODE_FLS(buf_out, cls + 1);       /* uint32  | size   6 */  \
+        _02_27_ENCODE_LLS(buf_out, cls + 5);       /* uint32  | size   6 */  \
+        _06_01_ENCODE_DROPS_AMOUNT(                                          \
+            buf_out, drops_amount); /* amount  | size   9 */                 \
+        uint8_t* fee_ptr = buf_out;                                          \
+        _06_08_ENCODE_DROPS_FEE(buf_out, 0);        /* amount  | size   9 */ \
+        _07_03_ENCODE_SIGNING_PUBKEY_NULL(buf_out); /* pk      | size  35 */ \
+        _08_01_ENCODE_ACCOUNT_SRC(buf_out, acc);    /* account | size  22 */ \
+        _08_03_ENCODE_ACCOUNT_DST(                                           \
+            buf_out, to_address); /* account | size  22 */                   \
+        int64_t edlen = etxn_details(                                        \
+            (uint32_t)buf_out,                                               \
+            PREPARE_PAYMENT_SIMPLE_SIZE); /* emitdet | size 1?? */           \
+        int64_t fee =                                                        \
+            etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_SIZE);      \
+        _06_08_ENCODE_DROPS_FEE(fee_ptr, fee);                               \
     }
 
 #ifdef HAS_CALLBACK
@@ -639,33 +645,35 @@ int out_len = 0;\
 #else
 #define PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE 287
 #endif
-#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE(buf_out_master, tlamt, to_address, dest_tag_raw, src_tag_raw)\
-    {\
-        uint8_t* buf_out = buf_out_master;\
-        uint8_t acc[20];\
-        uint32_t dest_tag = (dest_tag_raw);\
-        uint32_t src_tag = (src_tag_raw);\
-        uint32_t cls = (uint32_t)ledger_seq();\
-        hook_account(SBUF(acc));\
-        _01_02_ENCODE_TT                   (buf_out, ttPAYMENT                      );      /* uint16  | size   3 */ \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );      /* uint32  | size   5 */ \
-        _02_03_ENCODE_TAG_SRC              (buf_out, src_tag                        );      /* uint32  | size   5 */ \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );      /* uint32  | size   5 */ \
-        _02_14_ENCODE_TAG_DST              (buf_out, dest_tag                       );      /* uint32  | size   5 */ \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );      /* uint32  | size   6 */ \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );      /* uint32  | size   6 */ \
-        _06_01_ENCODE_TL_AMOUNT            (buf_out, tlamt                          );      /* amount  | size  48 */ \
-        uint8_t* fee_ptr = buf_out;\
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );      /* amount  | size   9 */ \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );      /* pk      | size  35 */ \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );      /* account | size  22 */ \
-        _08_03_ENCODE_ACCOUNT_DST          (buf_out, to_address                     );      /* account | size  22 */ \
-        etxn_details((uint32_t)buf_out, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);             /* emitdet | size 1?? */  \
-        int64_t fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);                          \ 
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );                               \
+#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE(                                    \
+    buf_out_master, tlamt, to_address, dest_tag_raw, src_tag_raw)            \
+    {                                                                        \
+        uint8_t* buf_out = buf_out_master;                                   \
+        uint8_t acc[20];                                                     \
+        uint32_t dest_tag = (dest_tag_raw);                                  \
+        uint32_t src_tag = (src_tag_raw);                                    \
+        uint32_t cls = (uint32_t)ledger_seq();                               \
+        hook_account(SBUF(acc));                                             \
+        _01_02_ENCODE_TT(buf_out, ttPAYMENT);      /* uint16  | size   3 */  \
+        _02_02_ENCODE_FLAGS(buf_out, tfCANONICAL); /* uint32  | size   5 */  \
+        _02_03_ENCODE_TAG_SRC(buf_out, src_tag);   /* uint32  | size   5 */  \
+        _02_04_ENCODE_SEQUENCE(buf_out, 0);        /* uint32  | size   5 */  \
+        _02_14_ENCODE_TAG_DST(buf_out, dest_tag);  /* uint32  | size   5 */  \
+        _02_26_ENCODE_FLS(buf_out, cls + 1);       /* uint32  | size   6 */  \
+        _02_27_ENCODE_LLS(buf_out, cls + 5);       /* uint32  | size   6 */  \
+        _06_01_ENCODE_TL_AMOUNT(buf_out, tlamt);   /* amount  | size  48 */  \
+        uint8_t* fee_ptr = buf_out;                                          \
+        _06_08_ENCODE_DROPS_FEE(buf_out, 0);        /* amount  | size   9 */ \
+        _07_03_ENCODE_SIGNING_PUBKEY_NULL(buf_out); /* pk      | size  35 */ \
+        _08_01_ENCODE_ACCOUNT_SRC(buf_out, acc);    /* account | size  22 */ \
+        _08_03_ENCODE_ACCOUNT_DST(                                           \
+            buf_out, to_address); /* account | size  22 */                   \
+        etxn_details(                                                        \
+            (uint32_t)buf_out,                                               \
+            PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE); /* emitdet | size 1?? */ \
+        int64_t fee = etxn_fee_base(                                         \
+            buf_out_master, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);          \
+        _06_08_ENCODE_DROPS_FEE(fee_ptr, fee);                               \
     }
 
-
-
 #endif
-

hook/genesis/headers/sfcodes.h

@@ -3,18 +3,30 @@
 #define sfCloseResolution ((16U << 16U) + 1U)
 #define sfMethod ((16U << 16U) + 2U)
 #define sfTransactionResult ((16U << 16U) + 3U)
+#define sfScale ((16U << 16U) + 4U)
+#define sfAssetScale ((16U << 16U) + 5U)
 #define sfTickSize ((16U << 16U) + 16U)
 #define sfUNLModifyDisabling ((16U << 16U) + 17U)
 #define sfHookResult ((16U << 16U) + 18U)
+#define sfWasLockingChainSend ((16U << 16U) + 19U)
+#define sfSidecarType ((16U << 16U) + 20U)
+#define sfEntropyTier ((16U << 16U) + 21U)
 #define sfLedgerEntryType ((1U << 16U) + 1U)
 #define sfTransactionType ((1U << 16U) + 2U)
 #define sfSignerWeight ((1U << 16U) + 3U)
 #define sfTransferFee ((1U << 16U) + 4U)
+#define sfTradingFee ((1U << 16U) + 5U)
+#define sfDiscountedFee ((1U << 16U) + 6U)
 #define sfVersion ((1U << 16U) + 16U)
 #define sfHookStateChangeCount ((1U << 16U) + 17U)
 #define sfHookEmitCount ((1U << 16U) + 18U)
 #define sfHookExecutionIndex ((1U << 16U) + 19U)
 #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 sfEntropyDenominator ((1U << 16U) + 100U)
 #define sfNetworkID ((2U << 16U) + 1U)
 #define sfFlags ((2U << 16U) + 2U)
 #define sfSourceTag ((2U << 16U) + 3U)
@@ -29,6 +41,7 @@
 #define sfWalletSize ((2U << 16U) + 12U)
 #define sfOwnerCount ((2U << 16U) + 13U)
 #define sfDestinationTag ((2U << 16U) + 14U)
+#define sfLastUpdateTime ((2U << 16U) + 15U)
 #define sfHighQualityIn ((2U << 16U) + 16U)
 #define sfHighQualityOut ((2U << 16U) + 17U)
 #define sfLowQualityIn ((2U << 16U) + 18U)
@@ -60,10 +73,19 @@
 #define sfBurnedNFTokens ((2U << 16U) + 44U)
 #define sfHookStateCount ((2U << 16U) + 45U)
 #define sfEmitGeneration ((2U << 16U) + 46U)
-#define sfLockCount ((2U << 16U) + 47U)
+#define sfVoteWeight ((2U << 16U) + 48U)
+#define sfLockCount ((2U << 16U) + 49U)
+#define sfFirstNFTokenSequence ((2U << 16U) + 50U)
+#define sfOracleDocumentID ((2U << 16U) + 51U)
+#define sfStartTime ((2U << 16U) + 93U)
+#define sfRepeatCount ((2U << 16U) + 94U)
+#define sfDelaySeconds ((2U << 16U) + 95U)
+#define sfXahauActivationLgrSeq ((2U << 16U) + 96U)
+#define sfImportSequence ((2U << 16U) + 97U)
 #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)
@@ -80,12 +102,25 @@
 #define sfHookInstructionCount ((3U << 16U) + 17U)
 #define sfHookReturnCode ((3U << 16U) + 18U)
 #define sfReferenceCount ((3U << 16U) + 19U)
+#define sfXChainClaimID ((3U << 16U) + 20U)
+#define sfXChainAccountCreateCount ((3U << 16U) + 21U)
+#define sfXChainAccountClaimCount ((3U << 16U) + 22U)
+#define sfAssetPrice ((3U << 16U) + 23U)
+#define sfMaximumAmount ((3U << 16U) + 24U)
+#define sfOutstandingAmount ((3U << 16U) + 25U)
+#define sfMPTAmount ((3U << 16U) + 26U)
+#define sfIssuerNode ((3U << 16U) + 27U)
+#define sfSubjectNode ((3U << 16U) + 28U)
+#define sfTouchCount ((3U << 16U) + 97U)
+#define sfAccountIndex ((3U << 16U) + 98U)
+#define sfAccountCount ((3U << 16U) + 99U)
 #define sfRewardAccumulator ((3U << 16U) + 100U)
 #define sfEmailHash ((4U << 16U) + 1U)
-#define sfTakerPaysCurrency ((10U << 16U) + 1U)
-#define sfTakerPaysIssuer ((10U << 16U) + 2U)
-#define sfTakerGetsCurrency ((10U << 16U) + 3U)
-#define sfTakerGetsIssuer ((10U << 16U) + 4U)
+#define sfTakerPaysCurrency ((17U << 16U) + 1U)
+#define sfTakerPaysIssuer ((17U << 16U) + 2U)
+#define sfTakerGetsCurrency ((17U << 16U) + 3U)
+#define sfTakerGetsIssuer ((17U << 16U) + 4U)
+#define sfMPTokenIssuanceID ((21U << 16U) + 1U)
 #define sfLedgerHash ((5U << 16U) + 1U)
 #define sfParentHash ((5U << 16U) + 2U)
 #define sfTransactionHash ((5U << 16U) + 3U)
@@ -99,6 +134,8 @@
 #define sfEmitParentTxnID ((5U << 16U) + 11U)
 #define sfEmitNonce ((5U << 16U) + 12U)
 #define sfEmitHookHash ((5U << 16U) + 13U)
+#define sfObjectID ((5U << 16U) + 14U)
+#define sfAMMID ((5U << 16U) + 15U)
 #define sfBookDirectory ((5U << 16U) + 16U)
 #define sfInvoiceID ((5U << 16U) + 17U)
 #define sfNickname ((5U << 16U) + 18U)
@@ -120,6 +157,16 @@
 #define sfOfferID ((5U << 16U) + 34U)
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
+#define sfDomainID ((5U << 16U) + 37U)
+#define sfExportSignatureHash ((5U << 16U) + 38U)
+#define sfHookOnOutgoing ((5U << 16U) + 93U)
+#define sfHookOnIncoming ((5U << 16U) + 94U)
+#define sfCron ((5U << 16U) + 95U)
+#define sfHookCanEmit ((5U << 16U) + 96U)
+#define sfEmittedTxnID ((5U << 16U) + 97U)
+#define sfGovernanceMarks ((5U << 16U) + 98U)
+#define sfGovernanceFlags ((5U << 16U) + 99U)
+#define sfNumber ((9U << 16U) + 1U)
 #define sfAmount ((6U << 16U) + 1U)
 #define sfBalance ((6U << 16U) + 2U)
 #define sfLimitAmount ((6U << 16U) + 3U)
@@ -130,12 +177,26 @@
 #define sfFee ((6U << 16U) + 8U)
 #define sfSendMax ((6U << 16U) + 9U)
 #define sfDeliverMin ((6U << 16U) + 10U)
+#define sfAmount2 ((6U << 16U) + 11U)
+#define sfBidMin ((6U << 16U) + 12U)
+#define sfBidMax ((6U << 16U) + 13U)
 #define sfMinimumOffer ((6U << 16U) + 16U)
 #define sfRippleEscrow ((6U << 16U) + 17U)
 #define sfDeliveredAmount ((6U << 16U) + 18U)
 #define sfNFTokenBrokerFee ((6U << 16U) + 19U)
 #define sfHookCallbackFee ((6U << 16U) + 20U)
 #define sfLockedBalance ((6U << 16U) + 21U)
+#define sfBaseFeeDrops ((6U << 16U) + 22U)
+#define sfReserveBaseDrops ((6U << 16U) + 23U)
+#define sfReserveIncrementDrops ((6U << 16U) + 24U)
+#define sfLPTokenOut ((6U << 16U) + 25U)
+#define sfLPTokenIn ((6U << 16U) + 26U)
+#define sfEPrice ((6U << 16U) + 27U)
+#define sfPrice ((6U << 16U) + 28U)
+#define sfSignatureReward ((6U << 16U) + 29U)
+#define sfMinAccountCreateAmount ((6U << 16U) + 30U)
+#define sfLPTokenBalance ((6U << 16U) + 31U)
+#define sfTrustLineRewardAccumulator ((6U << 16U) + 99U)
 #define sfPublicKey ((7U << 16U) + 1U)
 #define sfMessageKey ((7U << 16U) + 2U)
 #define sfSigningPubKey ((7U << 16U) + 3U)
@@ -161,6 +222,16 @@
 #define sfHookParameterName ((7U << 16U) + 24U)
 #define sfHookParameterValue ((7U << 16U) + 25U)
 #define sfBlob ((7U << 16U) + 26U)
+#define sfDIDDocument ((7U << 16U) + 27U)
+#define sfData ((7U << 16U) + 28U)
+#define sfAssetClass ((7U << 16U) + 29U)
+#define sfProvider ((7U << 16U) + 30U)
+#define sfMPTokenMetadata ((7U << 16U) + 31U)
+#define sfCredentialType ((7U << 16U) + 32U)
+#define sfEntropyContributors ((7U << 16U) + 33U)
+#define sfHookName ((7U << 16U) + 97U)
+#define sfRemarkValue ((7U << 16U) + 98U)
+#define sfRemarkName ((7U << 16U) + 99U)
 #define sfAccount ((8U << 16U) + 1U)
 #define sfOwner ((8U << 16U) + 2U)
 #define sfDestination ((8U << 16U) + 3U)
@@ -170,13 +241,32 @@
 #define sfRegularKey ((8U << 16U) + 8U)
 #define sfNFTokenMinter ((8U << 16U) + 9U)
 #define sfEmitCallback ((8U << 16U) + 10U)
+#define sfHolder ((8U << 16U) + 11U)
 #define sfHookAccount ((8U << 16U) + 16U)
+#define sfOtherChainSource ((8U << 16U) + 18U)
+#define sfOtherChainDestination ((8U << 16U) + 19U)
+#define sfAttestationSignerAccount ((8U << 16U) + 20U)
+#define sfAttestationRewardAccount ((8U << 16U) + 21U)
+#define sfLockingChainDoor ((8U << 16U) + 22U)
+#define sfIssuingChainDoor ((8U << 16U) + 23U)
+#define sfSubject ((8U << 16U) + 24U)
+#define sfInform ((8U << 16U) + 99U)
 #define sfIndexes ((19U << 16U) + 1U)
 #define sfHashes ((19U << 16U) + 2U)
 #define sfAmendments ((19U << 16U) + 3U)
 #define sfNFTokenOffers ((19U << 16U) + 4U)
 #define sfHookNamespaces ((19U << 16U) + 5U)
+#define sfCredentialIDs ((19U << 16U) + 6U)
+#define sfURITokenIDs ((19U << 16U) + 99U)
 #define sfPaths ((18U << 16U) + 1U)
+#define sfBaseAsset ((26U << 16U) + 1U)
+#define sfQuoteAsset ((26U << 16U) + 2U)
+#define sfLockingChainIssue ((24U << 16U) + 1U)
+#define sfIssuingChainIssue ((24U << 16U) + 2U)
+#define sfAsset ((24U << 16U) + 3U)
+#define sfAsset2 ((24U << 16U) + 4U)
+#define sfClaimCurrency ((24U << 16U) + 5U)
+#define sfXChainBridge ((25U << 16U) + 1U)
 #define sfTransactionMetaData ((14U << 16U) + 2U)
 #define sfCreatedNode ((14U << 16U) + 3U)
 #define sfDeletedNode ((14U << 16U) + 4U)
@@ -195,9 +285,28 @@
 #define sfDisabledValidator ((14U << 16U) + 19U)
 #define sfEmittedTxn ((14U << 16U) + 20U)
 #define sfHookExecution ((14U << 16U) + 21U)
-#define sfHookDefinition ((14U << 16U) + 22U)
 #define sfHookParameter ((14U << 16U) + 23U)
 #define sfHookGrant ((14U << 16U) + 24U)
+#define sfVoteEntry ((14U << 16U) + 25U)
+#define sfAuctionSlot ((14U << 16U) + 26U)
+#define sfAuthAccount ((14U << 16U) + 27U)
+#define sfXChainClaimProofSig ((14U << 16U) + 28U)
+#define sfXChainCreateAccountProofSig ((14U << 16U) + 29U)
+#define sfXChainClaimAttestationCollectionElement ((14U << 16U) + 30U)
+#define sfXChainCreateAccountAttestationCollectionElement ((14U << 16U) + 31U)
+#define sfPriceData ((14U << 16U) + 32U)
+#define sfCredential ((14U << 16U) + 33U)
+#define sfExportedTxn ((14U << 16U) + 90U)
+#define sfAmountEntry ((14U << 16U) + 91U)
+#define sfMintURIToken ((14U << 16U) + 92U)
+#define sfHookEmission ((14U << 16U) + 93U)
+#define sfImportVLKey ((14U << 16U) + 94U)
+#define sfActiveValidator ((14U << 16U) + 95U)
+#define sfGenesisMint ((14U << 16U) + 96U)
+#define sfRemark ((14U << 16U) + 97U)
+#define sfHighReward ((14U << 16U) + 98U)
+#define sfLowReward ((14U << 16U) + 99U)
+#define sfExportResult ((14U << 16U) + 100U)
 #define sfSigners ((15U << 16U) + 3U)
 #define sfSignerEntries ((15U << 16U) + 4U)
 #define sfTemplate ((15U << 16U) + 5U)
@@ -207,9 +316,22 @@
 #define sfMemos ((15U << 16U) + 9U)
 #define sfNFTokens ((15U << 16U) + 10U)
 #define sfHooks ((15U << 16U) + 11U)
+#define sfVoteSlots ((15U << 16U) + 12U)
 #define sfMajorities ((15U << 16U) + 16U)
 #define sfDisabledValidators ((15U << 16U) + 17U)
 #define sfHookExecutions ((15U << 16U) + 18U)
 #define sfHookParameters ((15U << 16U) + 19U)
 #define sfHookGrants ((15U << 16U) + 20U)
-#define sfActiveValidators ((15U << 16U) + 95U)
+#define sfXChainClaimAttestations ((15U << 16U) + 21U)
+#define sfXChainCreateAccountAttestations ((15U << 16U) + 22U)
+#define sfPriceDataSeries ((15U << 16U) + 24U)
+#define sfAuthAccounts ((15U << 16U) + 25U)
+#define sfAuthorizeCredentials ((15U << 16U) + 26U)
+#define sfUnauthorizeCredentials ((15U << 16U) + 27U)
+#define sfAcceptedCredentials ((15U << 16U) + 28U)
+#define sfAmounts ((15U << 16U) + 92U)
+#define sfHookEmissions ((15U << 16U) + 93U)
+#define sfImportVLKeys ((15U << 16U) + 94U)
+#define sfActiveValidators ((15U << 16U) + 95U)
+#define sfGenesisMints ((15U << 16U) + 96U)
+#define sfRemarks ((15U << 16U) + 97U)

hook/sfcodes.h

@@ -9,6 +9,8 @@
 #define sfUNLModifyDisabling ((16U << 16U) + 17U)
 #define sfHookResult ((16U << 16U) + 18U)
 #define sfWasLockingChainSend ((16U << 16U) + 19U)
+#define sfSidecarType ((16U << 16U) + 20U)
+#define sfEntropyTier ((16U << 16U) + 21U)
 #define sfLedgerEntryType ((1U << 16U) + 1U)
 #define sfTransactionType ((1U << 16U) + 2U)
 #define sfSignerWeight ((1U << 16U) + 3U)
@@ -22,6 +24,9 @@
 #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 sfEntropyDenominator ((1U << 16U) + 100U)
 #define sfNetworkID ((2U << 16U) + 1U)
 #define sfFlags ((2U << 16U) + 2U)
 #define sfSourceTag ((2U << 16U) + 3U)
@@ -80,6 +85,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)
@@ -152,6 +158,7 @@
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
 #define sfDomainID ((5U << 16U) + 37U)
+#define sfExportSignatureHash ((5U << 16U) + 38U)
 #define sfHookOnOutgoing ((5U << 16U) + 93U)
 #define sfHookOnIncoming ((5U << 16U) + 94U)
 #define sfCron ((5U << 16U) + 95U)
@@ -189,6 +196,7 @@
 #define sfSignatureReward ((6U << 16U) + 29U)
 #define sfMinAccountCreateAmount ((6U << 16U) + 30U)
 #define sfLPTokenBalance ((6U << 16U) + 31U)
+#define sfTrustLineRewardAccumulator ((6U << 16U) + 99U)
 #define sfPublicKey ((7U << 16U) + 1U)
 #define sfMessageKey ((7U << 16U) + 2U)
 #define sfSigningPubKey ((7U << 16U) + 3U)
@@ -220,6 +228,8 @@
 #define sfProvider ((7U << 16U) + 30U)
 #define sfMPTokenMetadata ((7U << 16U) + 31U)
 #define sfCredentialType ((7U << 16U) + 32U)
+#define sfEntropyContributors ((7U << 16U) + 33U)
+#define sfHookName ((7U << 16U) + 97U)
 #define sfRemarkValue ((7U << 16U) + 98U)
 #define sfRemarkName ((7U << 16U) + 99U)
 #define sfAccount ((8U << 16U) + 1U)
@@ -255,6 +265,7 @@
 #define sfIssuingChainIssue ((24U << 16U) + 2U)
 #define sfAsset ((24U << 16U) + 3U)
 #define sfAsset2 ((24U << 16U) + 4U)
+#define sfClaimCurrency ((24U << 16U) + 5U)
 #define sfXChainBridge ((25U << 16U) + 1U)
 #define sfTransactionMetaData ((14U << 16U) + 2U)
 #define sfCreatedNode ((14U << 16U) + 3U)
@@ -285,6 +296,7 @@
 #define sfXChainCreateAccountAttestationCollectionElement ((14U << 16U) + 31U)
 #define sfPriceData ((14U << 16U) + 32U)
 #define sfCredential ((14U << 16U) + 33U)
+#define sfExportedTxn ((14U << 16U) + 90U)
 #define sfAmountEntry ((14U << 16U) + 91U)
 #define sfMintURIToken ((14U << 16U) + 92U)
 #define sfHookEmission ((14U << 16U) + 93U)
@@ -292,6 +304,9 @@
 #define sfActiveValidator ((14U << 16U) + 95U)
 #define sfGenesisMint ((14U << 16U) + 96U)
 #define sfRemark ((14U << 16U) + 97U)
+#define sfHighReward ((14U << 16U) + 98U)
+#define sfLowReward ((14U << 16U) + 99U)
+#define sfExportResult ((14U << 16U) + 100U)
 #define sfSigners ((15U << 16U) + 3U)
 #define sfSignerEntries ((15U << 16U) + 4U)
 #define sfTemplate ((15U << 16U) + 5U)

hook/tts.h

@@ -61,6 +61,7 @@
 #define ttNFTOKEN_MODIFY 70
 #define ttPERMISSIONED_DOMAIN_SET 71
 #define ttPERMISSIONED_DOMAIN_DELETE 72
+#define ttEXPORT 91
 #define ttCRON 92
 #define ttCRON_SET 93
 #define ttREMARKS_SET 94
@@ -74,3 +75,5 @@
 #define ttUNL_MODIFY 102
 #define ttEMIT_FAILURE 103
 #define ttUNL_REPORT 104
+#define ttCONSENSUS_ENTROPY 105
+#define ttEXPORT_SIGNATURES 106

hook/tx_flags.h

@@ -115,3 +115,8 @@ enum AMMClawbackFlags : uint32_t {
 enum BridgeModifyFlags : uint32_t {
     tfClearAccountCreateAmount = 0x00010000,
 };
+
+enum ConsensusEntropyFlags : uint32_t {
+    tfEntropyCommit = 0x00000001,  // entry is a commitment in commitSet
+    tfEntropyReveal = 0x00000002,  // entry is a reveal in entropySet
+};

include/xrpl/hook/Enum.h

@@ -15,7 +15,10 @@
 #define uint256 std::string
 #define featureHooksUpdate1 "1"
 #define featureHooksUpdate2 "1"
+#define featureExport "1"
+#define featureConsensusEntropy "1"
 #define fix20250131 "1"
+#define fixGuardDepth32 "1"
 namespace hook_api {
 struct Rules
 {
@@ -264,11 +267,8 @@ enum hook_log_code : uint16_t {
     SECTIONS_OUT_OF_SEQUENCE =
         85,  // the wasm contained sections out of sequence
     CUSTOM_SECTION_DISALLOWED =
-        86,                // the wasm contained a custom section (id=0)
-    INTERNAL_ERROR = 87,   // an internal error described by the log text
-    JS_TEST_FAILURE = 88,  // smoke test of js bytecode failed
-    JS_FEE_MISSING = 89,
-    JS_FEE_OUT_OF_RANGE = 90,
+        86,               // the wasm contained a custom section (id=0)
+    INTERNAL_ERROR = 87,  // an internal error described by the log text
     // RH NOTE: only HookSet msgs got log codes, possibly all Hook log lines
     // should get a code?
 };
@@ -322,7 +322,7 @@ namespace compare_mode {
 enum compare_mode : uint32_t { EQUAL = 1, LESS = 2, GREATER = 4 };
 }
 
-enum hook_return_code : int64_t {
+enum class hook_return_code : int64_t {
     SUCCESS =
         0,  // return codes > 0 are reserved for hook apis to return "success"
     OUT_OF_BOUNDS =
@@ -386,29 +386,24 @@ enum hook_return_code : int64_t {
     MEM_OVERLAP = -43,   // one or more specified buffers are the same memory
     TOO_MANY_STATE_MODIFICATIONS = -44,  // more than 5000 modified state
                                          // entires in the combined hook chains
-    TOO_MANY_NAMESPACES = -45
+    TOO_MANY_NAMESPACES = -45,
+    EXPORT_FAILURE = -46,
+    TOO_MANY_EXPORTED_TXN = -47,
+    TOO_LITTLE_ENTROPY = -48,
 };
 
-enum ExitType : uint8_t {
+enum class ExitType : uint8_t {
     UNSET = 0,
     WASM_ERROR = 1,
     ROLLBACK = 2,
     ACCEPT = 3,
-    JSVM_ERROR = 4,
-    LEDGER_ERROR =
-        5,  // if the ledger contained for example a nonsense hookapi number
-    INSTRUCTION_LIMIT_REACHED = 6,
-};
-
-enum CodeType : uint8_t {
-    WASM = 0,
-    JS = 1,
 };
 
 const uint16_t max_state_modifications = 256;
 const uint8_t max_slots = 255;
 const uint8_t max_nonce = 255;
 const uint8_t max_emit = 255;
+const uint8_t max_export = 2;
 const uint8_t max_params = 16;
 const double fee_base_multiplier = 1.1f;
 
@@ -436,10 +431,6 @@ getImportWhitelist(Rules const& rules)
     if (AMENDMENT == uint256{} || rules.enabled(AMENDMENT)) \
         whitelist[#FUNCTION_NAME] = {                       \
             RETURN_TYPE, HOOK_WRAP_PARAMS PARAMS_TUPLE};
-#define JSHOOK_API_DEFINITION(                           \
-    RETURN_TYPE, FUNCTION_NAME, PARAMS_TUPLE, AMENDMENT) \
-    {                                                    \
-    }
 
 #include "hook_api.macro"
 
@@ -453,12 +444,9 @@ getImportWhitelist(Rules const& rules)
     return whitelist;
 }
 
-#undef HOOK_API_DEFINITION
-#undef I32
-#undef I64
-
 enum GuardRulesVersion : uint64_t {
     GuardRuleFix20250131 = 0x00000001,
+    GuardRuleDepth32 = 0x00000002,
 };
 
 inline uint64_t
@@ -467,6 +455,8 @@ getGuardRulesVersion(Rules const& rules)
     uint64_t version = 0;
     if (rules.enabled(fix20250131))
         version |= GuardRuleFix20250131;
+    if (rules.enabled(fixGuardDepth32))
+        version |= GuardRuleDepth32;
     return version;
 }
 

include/xrpl/hook/Guard.h

@@ -204,9 +204,13 @@ struct WasmBlkInf
     }
 // compute worst case execution time
 inline uint64_t
-compute_wce(const WasmBlkInf* blk, int level, bool* recursion_limit_reached)
+compute_wce(
+    const WasmBlkInf* blk,
+    int level,
+    int max_level,
+    bool* recursion_limit_reached)
 {
-    if (level > 16)
+    if (level > max_level)
     {
         *recursion_limit_reached = true;
         return 0;
@@ -233,8 +237,8 @@ compute_wce(const WasmBlkInf* blk, int level, bool* recursion_limit_reached)
 
     if (blk->children.size() > 0)
         for (auto const& child : blk->children)
-            worst_case_execution +=
-                compute_wce(child, level + 1, recursion_limit_reached);
+            worst_case_execution += compute_wce(
+                child, level + 1, max_level, recursion_limit_reached);
 
     if (parent == 0 ||
         parent->iteration_bound ==
@@ -788,12 +792,17 @@ check_guard(
     }
 
     bool recursion_limit_reached = false;
-    uint64_t wce = compute_wce(&(*root), 0, &recursion_limit_reached);
+    int max_level = 16;
+    if (rulesVersion & hook_api::GuardRuleDepth32)
+        max_level = 32;
+    uint64_t wce =
+        compute_wce(&(*root), 0, max_level, &recursion_limit_reached);
     if (recursion_limit_reached)
     {
         GUARDLOG(hook::log::NESTING_LIMIT)
             << "GuardCheck "
-            << "Maximum allowable depth of blocks reached (16 levels). Flatten "
+            << "Maximum allowable depth of blocks reached (" << max_level
+            << " levels). Flatten "
                "your loops and conditions!.\n";
         return {};
     }

include/xrpl/hook/Macro.h

@@ -67,7 +67,6 @@
 #define SEP_int32_t LPAREN int32_t COMMA
 #define SEP_uint64_t LPAREN uint64_t COMMA
 #define SEP_int64_t LPAREN int64_t COMMA
-#define SEP_JSValue LPAREN JSValue COMMA
 
 #define VAL_uint32_t WasmEdge_ValueGetI32(in[_stack++])
 #define VAL_int32_t WasmEdge_ValueGetI32(in[_stack++])
@@ -90,174 +89,69 @@
 
 #define WASM_VAL_TYPE(T, b) CAT2(TYP_, T)
 
-#define HALF_COUNT(...) \
-    HALF_COUNT_IMPL(    \
-        __VA_ARGS__,    \
-        16,             \
-        16,             \
-        15,             \
-        15,             \
-        14,             \
-        14,             \
-        13,             \
-        13,             \
-        12,             \
-        12,             \
-        11,             \
-        11,             \
-        10,             \
-        10,             \
-        9,              \
-        9,              \
-        8,              \
-        8,              \
-        7,              \
-        7,              \
-        6,              \
-        6,              \
-        5,              \
-        5,              \
-        4,              \
-        4,              \
-        3,              \
-        3,              \
-        2,              \
-        2,              \
-        1,              \
-        1,              \
-        0,              \
-        0)
+#define UNSIGNED_TYPE(T) std::make_unsigned_t<T>
 
-#define HALF_COUNT_IMPL( \
-    _1,                  \
-    _2,                  \
-    _3,                  \
-    _4,                  \
-    _5,                  \
-    _6,                  \
-    _7,                  \
-    _8,                  \
-    _9,                  \
-    _10,                 \
-    _11,                 \
-    _12,                 \
-    _13,                 \
-    _14,                 \
-    _15,                 \
-    _16,                 \
-    _17,                 \
-    _18,                 \
-    _19,                 \
-    _20,                 \
-    _21,                 \
-    _22,                 \
-    _23,                 \
-    _24,                 \
-    _25,                 \
-    _26,                 \
-    _27,                 \
-    _28,                 \
-    _29,                 \
-    _30,                 \
-    _31,                 \
-    _32,                 \
-    N,                   \
-    ...)                 \
-    N
-
-#define DECLARE_WASM_FUNCTION(R, F, ...)                         \
-    R F(hook::HookContext& hookCtx,                              \
-        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__( \
-            COMMA __VA_ARGS__));                                 \
-    extern WasmEdge_Result WasmFunction##F(                      \
-        void* data_ptr,                                          \
-        const WasmEdge_CallingFrameContext* frameCtx,            \
-        const WasmEdge_Value* in,                                \
-        WasmEdge_Value* out);                                    \
-    extern WasmEdge_ValType WasmFunctionParams##F[];             \
-    extern WasmEdge_ValType WasmFunctionResult##F[];             \
-    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F;    \
+#define DECLARE_HOOK_FUNCTION(R, F, ...)                          \
+    std::variant<UNSIGNED_TYPE(R), hook_api::hook_return_code> F( \
+        hook::HookContext& hookCtx,                               \
+        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(  \
+            COMMA __VA_ARGS__));                                  \
+    extern WasmEdge_Result WasmFunction##F(                       \
+        void* data_ptr,                                           \
+        const WasmEdge_CallingFrameContext* frameCtx,             \
+        const WasmEdge_Value* in,                                 \
+        WasmEdge_Value* out);                                     \
+    extern WasmEdge_ValType WasmFunctionParams##F[];              \
+    extern WasmEdge_ValType WasmFunctionResult##F[];              \
+    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F;     \
     extern WasmEdge_String WasmFunctionName##F;
 
-#define DECLARE_JS_FUNCTION(R, F, ...)                                        \
-    extern JSValue JSFunction##F(                                             \
-        JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv); \
-    const int JSFunctionParamCount##F = __VA_OPT__(HALF_COUNT(__VA_ARGS__) +) 0;
-
-#define DEFINE_WASM_FUNCTION(R, F, ...)                             \
-    WasmEdge_Result hook_api::WasmFunction##F(                      \
-        void* data_ptr,                                             \
-        const WasmEdge_CallingFrameContext* frameCtx,               \
-        const WasmEdge_Value* in,                                   \
-        WasmEdge_Value* out)                                        \
-    {                                                               \
-        __VA_OPT__(int _stack = 0;)                                 \
-        __VA_OPT__(FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);)           \
-        hook::HookContext* hookCtx =                                \
-            reinterpret_cast<hook::HookContext*>(data_ptr);         \
-        R return_code = hook_api::F(                                \
-            *hookCtx,                                               \
-            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)    \
-                __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));        \
-        if (return_code == RC_ROLLBACK || return_code == RC_ACCEPT) \
-            return WasmEdge_Result_Terminate;                       \
-        out[0] = RET_ASSIGN(R, return_code);                        \
-        return WasmEdge_Result_Success;                             \
-    };                                                              \
-    WasmEdge_ValType hook_api::WasmFunctionParams##F[] = {          \
-        __VA_OPT__(FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__))};       \
-    WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {         \
-        WASM_VAL_TYPE(R, dummy)};                                   \
-    WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =   \
-        WasmEdge_FunctionTypeCreate(                                \
-            WasmFunctionParams##F,                                  \
-            VA_NARGS(NULL __VA_OPT__(, __VA_ARGS__)),               \
-            WasmFunctionResult##F,                                  \
-            1);                                                     \
-    WasmEdge_String hook_api::WasmFunctionName##F =                 \
-        WasmEdge_StringCreateByCString(#F);                         \
-    R hook_api::F(                                                  \
-        hook::HookContext& hookCtx,                                 \
-        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(    \
+#define DEFINE_HOOK_FUNCTION(R, F, ...)                                        \
+    WasmEdge_Result hook_api::WasmFunction##F(                                 \
+        void* data_ptr,                                                        \
+        const WasmEdge_CallingFrameContext* frameCtx,                          \
+        const WasmEdge_Value* in,                                              \
+        WasmEdge_Value* out)                                                   \
+    {                                                                          \
+        __VA_OPT__(int _stack = 0;)                                            \
+        __VA_OPT__(FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);)                      \
+        hook::HookContext* hookCtx =                                           \
+            reinterpret_cast<hook::HookContext*>(data_ptr);                    \
+        auto const& return_code = hook_api::F(                                 \
+            *hookCtx,                                                          \
+            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)               \
+                __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));                   \
+        if (std::holds_alternative<hook_api::hook_return_code>(return_code) && \
+            (std::get<hook_api::hook_return_code>(return_code) ==              \
+                 RC_ROLLBACK ||                                                \
+             std::get<hook_api::hook_return_code>(return_code) == RC_ACCEPT))  \
+            return WasmEdge_Result_Terminate;                                  \
+        out[0] = RET_ASSIGN(                                                   \
+            R,                                                                 \
+            std::holds_alternative<UNSIGNED_TYPE(R)>(return_code)              \
+                ? std::get<UNSIGNED_TYPE(R)>(return_code)                      \
+                : R(std::get<hook_api::hook_return_code>(return_code)));       \
+        return WasmEdge_Result_Success;                                        \
+    };                                                                         \
+    WasmEdge_ValType hook_api::WasmFunctionParams##F[] = {                     \
+        __VA_OPT__(FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__))};                  \
+    WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {                    \
+        WASM_VAL_TYPE(R, dummy)};                                              \
+    WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =              \
+        WasmEdge_FunctionTypeCreate(                                           \
+            WasmFunctionParams##F,                                             \
+            VA_NARGS(NULL __VA_OPT__(, __VA_ARGS__)),                          \
+            WasmFunctionResult##F,                                             \
+            1);                                                                \
+    WasmEdge_String hook_api::WasmFunctionName##F =                            \
+        WasmEdge_StringCreateByCString(#F);                                    \
+    std::variant<UNSIGNED_TYPE(R), hook_api::hook_return_code> hook_api::F(    \
+        hook::HookContext& hookCtx,                                            \
+        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(               \
             COMMA __VA_ARGS__))
 
-#define VAR_JSASSIGN(T, V)          \
-    if (_stack >= argc)             \
-        returnJS(INVALID_ARGUMENT); \
-    T& V = argv[_stack++]
-
-#define FORWARD_JS_FUNCTION_CALL(F, ac, av) \
-    hook_api::JSFunction##F(ctx, this_val, ac, av)
-
-#define DEFINE_JS_FUNCTION(R, F, ...)                                        \
-    JSValue hook_api::JSFunction##F(                                         \
-        JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv) \
-    {                                                                        \
-        __VA_OPT__(int _stack = 0;)                                          \
-        __VA_OPT__(FOR_VARS(VAR_JSASSIGN, 2, __VA_ARGS__);)
-
-#define JS_HOOK_SETUP()                                                 \
-    JSRuntime* rt = JS_GetRuntime(ctx);                                 \
-    hook::HookContext& hookCtx =                                        \
-        *reinterpret_cast<hook::HookContext*>(JS_GetRuntimeOpaque(rt)); \
-    [[maybe_unused]] ApplyContext& applyCtx = hookCtx.applyCtx;         \
-    [[maybe_unused]] auto& view = applyCtx.view();                      \
-    [[maybe_unused]] auto j = applyCtx.app.journal("View");             \
-    [[maybe_unused]] auto& api = hookCtx.api();                         \
-    try                                                                 \
-    {
-#define JS_HOOK_TEARDOWN()                                        \
-    }                                                             \
-    catch (const std::exception& e)                               \
-    {                                                             \
-        JLOG(hookCtx.applyCtx.app.journal("View").error())        \
-            << "HookError[" << HC_ACC() << "]: (JS) " << __func__ \
-            << " threw uncaught exception, what=" << e.what();    \
-        return JS_NewInt64(ctx, INTERNAL_ERROR);                  \
-    }                                                             \
-    }
-
-#define WASM_HOOK_SETUP()                                            \
+#define HOOK_SETUP()                                                 \
+    using enum hook_api::hook_return_code;                           \
     try                                                              \
     {                                                                \
         [[maybe_unused]] ApplyContext& applyCtx = hookCtx.applyCtx;  \
@@ -274,14 +168,14 @@
         if (!memoryCtx || !memory || !memory_length)                 \
             return INTERNAL_ERROR;
 
-#define WASM_HOOK_TEARDOWN()                                        \
-    }                                                               \
-    catch (const std::exception& e)                                 \
-    {                                                               \
-        JLOG(hookCtx.applyCtx.app.journal("View").error())          \
-            << "HookError[" << HC_ACC() << "]: (WASM) " << __func__ \
-            << " threw uncaught exception, what=" << e.what();      \
-        return INTERNAL_ERROR;                                      \
+#define HOOK_TEARDOWN()                                        \
+    }                                                          \
+    catch (const std::exception& e)                            \
+    {                                                          \
+        JLOG(hookCtx.applyCtx.app.journal("View").error())     \
+            << "HookError[" << HC_ACC() << "]: " << __func__   \
+            << " threw uncaught exception, what=" << e.what(); \
+        return INTERNAL_ERROR;                                 \
     }
 
 #define WRITE_WASM_MEMORY(                                                  \
@@ -320,7 +214,7 @@
     host_memory_ptr,                  \
     guest_memory_length)              \
     {                                 \
-        int64_t bytes_written = 0;    \
+        uint64_t bytes_written = 0;   \
         WRITE_WASM_MEMORY(            \
             bytes_written,            \
             guest_dst_ptr,            \
@@ -375,28 +269,6 @@
                                                     : RC_ROLLBACK);            \
     }
 
-#define HOOK_EXIT_JS(error_msg, error_code, exit_type)                      \
-    {                                                                       \
-        int64_t val = 0;                                                    \
-        if (JS_IsNumber(error_code))                                        \
-            JS_ToInt64(ctx, &val, error_code);                              \
-        hookCtx.result.exitCode = val;                                      \
-        hookCtx.result.exitType = exit_type;                                \
-        if (JS_IsString(error_msg))                                         \
-        {                                                                   \
-            size_t len;                                                     \
-            const char* cstr = JS_ToCStringLen(ctx, &len, error_msg);       \
-            if (len > 256)                                                  \
-                len = 256;                                                  \
-            hookCtx.result.exitReason = std::string(cstr, len);             \
-            JS_FreeCString(ctx, cstr);                                      \
-        }                                                                   \
-        return JS_Exit(                                                     \
-            ctx,                                                            \
-            exit_type == hook_api::ExitType::ACCEPT ? "HookExit Accept"     \
-                                                    : "HookExit Rollback"); \
-    }
-
 #define WRITE_WASM_MEMORY_OR_RETURN_AS_INT64(                            \
     write_ptr_in, write_len_in, data_ptr_in, data_len_in, is_account_in) \
     {                                                                    \
@@ -411,7 +283,7 @@
             data_ptr < (data_ptr_in))                                    \
             return INTERNAL_ERROR;                                       \
         if (data_len == 0)                                               \
-            return 0;                                                    \
+            return 0ULL;                                                 \
         if ((write_ptr_in) == 0)                                         \
             return data_as_int64(data_ptr, data_len);                    \
         if (data_len > (write_len_in))                                   \

include/xrpl/hook/hook_api.macro

@@ -7,559 +7,311 @@ HOOK_API_DEFINITION(
 HOOK_API_DEFINITION(
   int64_t, accept, (uint32_t, uint32_t, int64_t),
   uint256{})
-// function accept(error_msg: string, error_code: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, accept, (JSValue, JSValue),
-  uint256{})
 
 // int64_t rollback(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
 HOOK_API_DEFINITION(
   int64_t, rollback, (uint32_t, uint32_t, int64_t),
   uint256{})
-// function rollback(error_msg: string, error_code: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, rollback, (JSValue, JSValue),
-  uint256{})
 
 // int64_t util_raddr(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, util_raddr, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_raddr(acc_id:string): string
-JSHOOK_API_DEFINITION(
-  JSValue, util_raddr, (JSValue),
-  uint256{})
 
 // int64_t util_accid(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, util_accid, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_accid(acc_id:string): string
-JSHOOK_API_DEFINITION(
-  JSValue, util_accid, (JSValue),
-  uint256{})
 
 // int64_t util_verify(uint32_t dread_ptr, uint32_t dread_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
   int64_t, util_verify, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_verify(data:string, sig: string, pubkey: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, util_verify, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t util_sha512h(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, util_sha512h, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_sha512h(data: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, util_sha512h, (JSValue),
-  uint256{})
 
 // int64_t util_keylet(uint32_t write_ptr, uint32_t write_len, uint32_t keylet_type, uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f);
 HOOK_API_DEFINITION(
   int64_t, util_keylet, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function util_keylet(keylet_type: number, keylet_data: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, util_keylet, (JSValue, JSValue),
-  uint256{})
 
 // int64_t sto_validate(uint32_t tread_ptr, uint32_t tread_len);
 HOOK_API_DEFINITION(
   int64_t, sto_validate, (uint32_t, uint32_t),
   uint256{})
-// function sto_validate(sto: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_validate, (JSValue),
-  uint256{})
 
 // int64_t sto_subfield(uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
 HOOK_API_DEFINITION(
   int64_t, sto_subfield, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function sto_subfield(sto: string, field_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_subfield, (JSValue, JSValue),
-  uint256{})
 
 // int64_t sto_subarray(uint32_t read_ptr, uint32_t read_len, uint32_t array_id);
 HOOK_API_DEFINITION(
   int64_t, sto_subarray, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function sto_subarray(sto: string, array_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_subarray, (JSValue, JSValue),
-  uint256{})
 
 // int64_t sto_emplace(uint32_t write_ptr, uint32_t write_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t fread_ptr, uint32_t fread_len, uint32_t field_id);
 HOOK_API_DEFINITION(
   int64_t, sto_emplace, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function sto_emplace(sto: string, field_bytes: number, field_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_emplace, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t sto_erase(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
 HOOK_API_DEFINITION(
   int64_t, sto_erase, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function sto_erase(sto: string, field_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_erase, (JSValue, JSValue),
-  uint256{})
 
 // int64_t etxn_burden();
 HOOK_API_DEFINITION(
   int64_t, etxn_burden, (),
   uint256{})
-// function etxn_burden(): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_burden, (),
-  uint256{})
 
 // int64_t etxn_details(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, etxn_details, (uint32_t, uint32_t),
   uint256{})
-// function etxn_details(): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_details, (),
-  uint256{})
 
 // int64_t etxn_fee_base(uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, etxn_fee_base, (uint32_t, uint32_t),
   uint256{})
-// function etxn_fee_base(txblob: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_fee_base, (JSValue),
-  uint256{})
 
 // int64_t etxn_reserve(uint32_t count);
 HOOK_API_DEFINITION(
   int64_t, etxn_reserve, (uint32_t),
   uint256{})
-// function etxn_reserve(count: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_reserve, (JSValue),
-  uint256{})
 
 // int64_t etxn_generation();
 HOOK_API_DEFINITION(
   int64_t, etxn_generation, (),
   uint256{})
-// function etxn_generation(): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_generation, (),
-  uint256{})
 
 // int64_t etxn_nonce(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, etxn_nonce, (uint32_t, uint32_t),
   uint256{})
-// function etxn_nonce(): number
-JSHOOK_API_DEFINITION(
-  JSValue, etxn_nonce, (),
-  uint256{})
 
 // int64_t emit(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, emit, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function emit(txn: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, emit, (JSValue),
-  uint256{})
 
 // int64_t float_set(int32_t exponent, int64_t mantissa);
 HOOK_API_DEFINITION(
   int64_t, float_set, (int32_t, int64_t),
   uint256{})
-// function float_set(e: number, m: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_set, (JSValue, JSValue),
-  uint256{})
 
 // int64_t float_multiply(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
   int64_t, float_multiply, (int64_t, int64_t),
   uint256{})
-// function float_multiply(f1: number, f2: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_multiply, (JSValue, JSValue),
-  uint256{})
 
 // int64_t float_mulratio(int64_t float1, uint32_t round_up, uint32_t numerator, uint32_t denominator);
 HOOK_API_DEFINITION(
   int64_t, float_mulratio, (int64_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function float_mulratio(f1: number, round_up: number, numerator: number, denominator: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_mulratio, (JSValue, JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t float_negate(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_negate, (int64_t),
   uint256{})
-// function float_negate(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_negate, (JSValue),
-  uint256{})
 
 // int64_t float_compare(int64_t float1, int64_t float2, uint32_t mode);
 HOOK_API_DEFINITION(
   int64_t, float_compare, (int64_t, int64_t, uint32_t),
   uint256{})
-// function float_compare(f1: number, f2: number, mode: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_compare, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t float_sum(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
   int64_t, float_sum, (int64_t, int64_t),
   uint256{})
-// function float_sum(f1: number, f2: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_sum, (JSValue, JSValue),
-  uint256{})
 
 // int64_t float_sto(uint32_t write_ptr, uint32_t write_len, uint32_t cread_ptr, uint32_t cread_len, uint32_t iread_ptr, uint32_t iread_len, int64_t float1, uint32_t field_code);
 HOOK_API_DEFINITION(
   int64_t, float_sto, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int64_t, uint32_t),
   uint256{})
-// function float_sto(cur: string, isu: string, float1: number, field_code: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_sto, (JSValue, JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t float_sto_set(uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, float_sto_set, (uint32_t, uint32_t),
   uint256{})
-// function float_sto_set(buf: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_sto_set, (JSValue),
-  uint256{})
 
 // int64_t float_invert(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_invert, (int64_t),
   uint256{})
-// function float_invert(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_invert, (JSValue),
-  uint256{})
 
 // int64_t float_divide(int64_t float1, int64_t float2);
 HOOK_API_DEFINITION(
   int64_t, float_divide, (int64_t, int64_t),
   uint256{})
-// function float_divide(f1: number, f2: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_divide, (JSValue, JSValue),
-  uint256{})
 
 // int64_t float_one();
 HOOK_API_DEFINITION(
   int64_t, float_one, (),
   uint256{})
-// function float_one(): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_one, (),
-  uint256{})
 
 // int64_t float_mantissa(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_mantissa, (int64_t),
   uint256{})
-// function float_mantissa(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_mantissa, (JSValue),
-  uint256{})
 
 // int64_t float_sign(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_sign, (int64_t),
   uint256{})
-// function float_sign(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_sign, (JSValue),
-  uint256{})
 
 // int64_t float_int(int64_t float1, uint32_t decimal_places, uint32_t abs);
 HOOK_API_DEFINITION(
   int64_t, float_int, (int64_t, uint32_t, uint32_t),
   uint256{})
-// function float_int(f1: number, decimal_places: number, abs: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_int, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t float_log(int64_t float1);
 HOOK_API_DEFINITION(
   int64_t, float_log, (int64_t),
   uint256{})
-// function float_log(f1: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_log, (JSValue),
-  uint256{})
 
 // int64_t float_root(int64_t float1, uint32_t n);
 HOOK_API_DEFINITION(
   int64_t, float_root, (int64_t, uint32_t),
   uint256{})
-// function float_root(f1: number, n: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, float_root, (JSValue, JSValue),
-  uint256{})
 
 // int64_t fee_base();
 HOOK_API_DEFINITION(
   int64_t, fee_base, (),
   uint256{})
-// function fee_base(): number
-JSHOOK_API_DEFINITION(
-  JSValue, fee_base, (),
-  uint256{})
 
 // int64_t ledger_seq();
 HOOK_API_DEFINITION(
   int64_t, ledger_seq, (),
   uint256{})
-// function ledger_seq(): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_seq, (),
-  uint256{})
 
 // int64_t ledger_last_time();
 HOOK_API_DEFINITION(
   int64_t, ledger_last_time, (),
   uint256{})
-// function ledger_last_time(): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_last_time, (),
-  uint256{})
 
 // int64_t ledger_last_hash(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, ledger_last_hash, (uint32_t, uint32_t),
   uint256{})
-// function ledger_last_hash(): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_last_hash, (),
-  uint256{})
 
 // int64_t ledger_nonce(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, ledger_nonce, (uint32_t, uint32_t),
   uint256{})
-// function ledger_nonce(): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_nonce, (),
-  uint256{})
 
 // int64_t ledger_keylet(uint32_t write_ptr, uint32_t write_len, uint32_t lread_ptr, uint32_t lread_len, uint32_t hread_ptr, uint32_t hread_len);
 HOOK_API_DEFINITION(
   int64_t, ledger_keylet, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function ledger_keylet(low: string, high: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, ledger_keylet, (JSValue, JSValue),
-  uint256{})
 
 // int64_t hook_account(uint32_t write_ptr, uint32_t write_len);
 HOOK_API_DEFINITION(
   int64_t, hook_account, (uint32_t, uint32_t),
   uint256{})
-// function hook_account(): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_account, (),
-  uint256{})
 
 // int64_t hook_hash(uint32_t write_ptr, uint32_t write_len, int32_t hook_no);
 HOOK_API_DEFINITION(
   int64_t, hook_hash, (uint32_t, uint32_t, int32_t),
   uint256{})
-// function hook_hash(hook_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_hash, (JSValue),
-  uint256{})
 
 // int64_t hook_param_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t hread_ptr, uint32_t hread_len);
 HOOK_API_DEFINITION(
   int64_t, hook_param_set, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function hook_param_set(value: string, key: string, hash: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_param_set, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t hook_param(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, hook_param, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function hook_param(key: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_param, (JSValue),
-  uint256{})
 
 // int64_t hook_again();
 HOOK_API_DEFINITION(
   int64_t, hook_again, (),
   uint256{})
-// function hook_again(): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_again, (),
-  uint256{})
 
 // int64_t hook_skip(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
 HOOK_API_DEFINITION(
   int64_t, hook_skip, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function hook_skip(hhash: string, flags: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_skip, (JSValue, JSValue),
-  uint256{})
 
 // int64_t hook_pos();
 HOOK_API_DEFINITION(
   int64_t, hook_pos, (),
   uint256{})
-// function hook_pos(): number
-JSHOOK_API_DEFINITION(
-  JSValue, hook_pos, (),
-  uint256{})
 
 // int64_t slot(uint32_t write_ptr, uint32_t write_len, uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function slot(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot, (JSValue),
-  uint256{})
 
 // int64_t slot_clear(uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot_clear, (uint32_t),
   uint256{})
-// function slot_clear(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_clear, (JSValue),
-  uint256{})
 
 // int64_t slot_count(uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot_count, (uint32_t),
   uint256{})
-// function slot_count(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_count, (JSValue),
-  uint256{})
 
 // int64_t slot_set(uint32_t read_ptr, uint32_t read_len, uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot_set, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function slot_set(kl: string, slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_set, (JSValue, JSValue),
-  uint256{})
 
 // int64_t slot_size(uint32_t slot);
 HOOK_API_DEFINITION(
   int64_t, slot_size, (uint32_t),
   uint256{})
-// function slot_size(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_size, (JSValue),
-  uint256{})
 
 // int64_t slot_subarray(uint32_t parent_slot, uint32_t array_id, uint32_t new_slot);
 HOOK_API_DEFINITION(
   int64_t, slot_subarray, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function slot_subarray(parent_slot_no: number, array_id: number, new_slot: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_subarray, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t slot_subfield(uint32_t parent_slot, uint32_t field_id, uint32_t new_slot);
 HOOK_API_DEFINITION(
   int64_t, slot_subfield, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function slot_subfield(parent_slot_no: number, field_id: number, new_slot: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_subfield, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t slot_type(uint32_t slot_no, uint32_t flags);
 HOOK_API_DEFINITION(
   int64_t, slot_type, (uint32_t, uint32_t),
   uint256{})
-// function slot_type(slot_no: number, flags: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_type, (JSValue, JSValue),
-  uint256{})
 
 // int64_t slot_float(uint32_t slot_no);
 HOOK_API_DEFINITION(
   int64_t, slot_float, (uint32_t),
   uint256{})
-// function slot_float(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_float, (JSValue),
-  uint256{})
 
 // int64_t state_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
   int64_t, state_set, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function state_set(val: string, key: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, state_set, (JSValue, JSValue),
-  uint256{})
 
 // int64_t state_foreign_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len);
 HOOK_API_DEFINITION(
   int64_t, state_foreign_set, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function state_foreign_set(val: string, key: string, ns: string, accid: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, state_foreign_set, (JSValue, JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t state(uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len);
 HOOK_API_DEFINITION(
   int64_t, state, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function state(key: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, state, (JSValue),
-  uint256{})
 
 // int64_t state_foreign(uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len);
 HOOK_API_DEFINITION(
   int64_t, state_foreign, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function state_foreign(key: string, ns: string, accid: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, state_foreign, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t trace(uint32_t mread_ptr, uint32_t mread_len, uint32_t dread_ptr, uint32_t dread_len, uint32_t as_hex);
 HOOK_API_DEFINITION(
   int64_t, trace, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function trace(msg: string, data: string, as_hex: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, trace, (JSValue, JSValue, JSValue),
-  uint256{})
 
 // int64_t trace_num(uint32_t read_ptr, uint32_t read_len, int64_t number);
 HOOK_API_DEFINITION(
@@ -575,108 +327,73 @@ HOOK_API_DEFINITION(
 HOOK_API_DEFINITION(
   int64_t, otxn_burden, (),
   uint256{})
-// function otxn_burden(): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_burden, (),
-  uint256{})
 
 // int64_t otxn_field(uint32_t write_ptr, uint32_t write_len, uint32_t field_id);
 HOOK_API_DEFINITION(
   int64_t, otxn_field, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function otxn_field(field_id: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_field, (JSValue),
-  uint256{})
 
 // int64_t otxn_generation();
 HOOK_API_DEFINITION(
   int64_t, otxn_generation, (),
   uint256{})
-// function otxn_generation(): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_generation, (),
-  uint256{})
 
 // int64_t otxn_id(uint32_t write_ptr, uint32_t write_len, uint32_t flags);
 HOOK_API_DEFINITION(
   int64_t, otxn_id, (uint32_t, uint32_t, uint32_t),
   uint256{})
-// function otxn_id(flags: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_id, (JSValue),
-  uint256{})
 
 // int64_t otxn_type();
 HOOK_API_DEFINITION(
   int64_t, otxn_type, (),
   uint256{})
-// function otxn_type(): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_type, (),
-  uint256{})
 
 // int64_t otxn_slot(uint32_t slot_no);
 HOOK_API_DEFINITION(
   int64_t, otxn_slot, (uint32_t),
   uint256{})
-// function otxn_slot(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_slot, (JSValue),
-  uint256{})
 
 // int64_t otxn_param(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, otxn_param, (uint32_t, uint32_t, uint32_t, uint32_t),
   uint256{})
-// function otxn_param(param_key: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_param, (JSValue),
-  uint256{})
 
 // int64_t meta_slot(uint32_t slot_no);
 HOOK_API_DEFINITION(
   int64_t, meta_slot, (uint32_t),
   uint256{})
-// function meta_slot(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, meta_slot, (JSValue),
-  uint256{})
 
 // int64_t xpop_slot(uint32_t slot_no_tx, uint32_t slot_no_meta);
 HOOK_API_DEFINITION(
   int64_t, xpop_slot, (uint32_t, uint32_t),
   featureHooksUpdate1)
-// function xpop_slot(slot_no_tx: number, slot_no_meta: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, xpop_slot, (JSValue, JSValue),
-  uint256{})
 
 // int64_t prepare(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
 HOOK_API_DEFINITION(
   int64_t, prepare, (uint32_t, uint32_t, uint32_t, uint32_t),
   featureHooksUpdate2)
-// function prepare(tmpl: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, prepare, (JSValue),
-  uint256{})
 
-// function otxn_json(): number
-JSHOOK_API_DEFINITION(
-  JSValue, otxn_json, (),
-  uint256{})
+// int64_t xport_reserve(uint32_t count);
+HOOK_API_DEFINITION(
+  int64_t, xport_reserve, (uint32_t),
+  featureExport)
 
-// function slot_json(slot_no: number): number
-JSHOOK_API_DEFINITION(
-  JSValue, slot_json, (JSValue),
-  uint256{})
+// int64_t xport(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, xport, (uint32_t, uint32_t, uint32_t, uint32_t),
+  featureExport)
 
-// function sto_to_json(sto_in: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_to_json, (JSValue),
-  uint256{})
+// int64_t xport_cancel(uint32_t ticket_seq);
+HOOK_API_DEFINITION(
+  int64_t, xport_cancel, (uint32_t),
+  featureExport)
 
-// function sto_from_json(json_in: string): number
-JSHOOK_API_DEFINITION(
-  JSValue, sto_from_json, (JSValue),
-  uint256{})
+// int64_t dice(uint32_t sides, uint32_t min_tier, uint32_t min_count);
+HOOK_API_DEFINITION(
+  int64_t, dice, (uint32_t, uint32_t, uint32_t),
+  featureConsensusEntropy)
+
+// int64_t random(uint32_t write_ptr, uint32_t write_len, uint32_t min_tier, uint32_t min_count);
+HOOK_API_DEFINITION(
+  int64_t, random, (uint32_t, uint32_t, uint32_t, uint32_t),
+  featureConsensusEntropy)

include/xrpl/proto/.clang-format

@@ -0,0 +1,2 @@
+---
+DisableFormat: true

include/xrpl/proto/ripple.proto

@@ -153,7 +153,11 @@ message TMStatusChange
 message TMProposeSet
 {
     required uint32 proposeSeq          = 1;
-    required bytes currentTxHash        = 2;    // the hash of the ledger we are proposing
+    // Proposed transaction-set identity. Legacy/plain proposals carry the
+    // tx-set hash directly; ConsensusExtensions proposals carry a serialized
+    // ExtendedPosition whose first field is that tx-set hash, followed by
+    // signed RNG/Export sidecar fields.
+    required bytes currentTxHash        = 2;
     required bytes nodePubKey           = 3;
     required uint32 closeTime           = 4;
     required bytes signature            = 5;    // signature of above fields
@@ -166,6 +170,14 @@ message TMProposeSet
 
     // Number of hops traveled
     optional uint32 hops                = 12    [deprecated=true];
+
+    // Export signatures for pending exports seen in the proposal set. The
+    // proposal's ExtendedPosition includes a digest of this repeated field, so
+    // these side-channel blobs are covered by the proposal signature.
+    // Each entry is: txnHash (32 bytes) + validator pubkey (33 bytes)
+    // + multisign signature (variable length). Validators attach these
+    // so export quorum can be reached within the same consensus round.
+    repeated bytes exportSignatures     = 13;
 }
 
 enum TxSetStatus
@@ -384,4 +396,3 @@ message TMHaveTransactions
 {
     repeated bytes hashes = 1;
 }
-

include/xrpl/protocol/EntropyTier.h

@@ -0,0 +1,62 @@
+#ifndef RIPPLE_PROTOCOL_ENTROPY_TIER_H_INCLUDED
+#define RIPPLE_PROTOCOL_ENTROPY_TIER_H_INCLUDED
+
+#include <cstdint>
+
+namespace ripple {
+
+/// Which gate the ledger's entropy passed. Stored in sfEntropyTier (UINT8)
+/// on the ttCONSENSUS_ENTROPY pseudo-transaction and the ConsensusEntropy
+/// ledger entry.
+///
+/// EntropyCount says how many validators contributed; EntropyDenominator says
+/// how many active validators were in the ledger-anchored view for that
+/// non-fallback result; EntropyTier says which gate the result passed. Fallback
+/// entropy carries count=0/denominator=0 because no validator-derived
+/// denominator was accepted. Tier values are strength-ordered so consumers can
+/// gate with a numeric comparison (tier >= required).
+///
+/// RESIDUAL BIAS — applies to fallback, participant_aligned, and
+/// validator_quorum. This is a commit/reveal scheme: a validator can withhold
+/// its reveal until after observing peers' reveals, choosing between two
+/// outcomes (its contribution in vs. out) — up to one bit of influence per
+/// withholder, and colluding withholders near a threshold can instead force a
+/// downgrade to a lower tier. These tiers bound and *label* manipulation (it is
+/// observable and limited); they are NOT bias-resistant against a colluding
+/// validator minority. A hook that requires validator_full fails closed if any
+/// active validator withholds, trading availability for no selective-
+/// withholding slack.
+enum EntropyTier : std::uint8_t {
+    /// No usable entropy (reserved; a fresh ConsensusEntropy entry should
+    /// always carry one of the tiers below).
+    entropyTierNone = 0,
+
+    /// Consensus-bound deterministic fallback: derived from already-agreed
+    /// round inputs (parent ledger hash, base tx set hash, sequence) under
+    /// HashPrefix::entropyFallback when no agreed reveal set reaches either
+    /// participant_aligned or validator_quorum. Unpredictable in practice but
+    /// user-influenceable via transaction submission — never suitable for
+    /// value-bearing outcomes.
+    entropyTierConsensusFallback = 1,
+
+    /// Participant-aligned sub-quorum entropy: the agreed reveal set aligned at
+    /// the tier-2 participant threshold — below the 80% validator quorum but at
+    /// or above the equivocation-intersection floor over the original
+    /// (pre-nUNL)
+    /// view. Weaker than validator_quorum; opt-in for hooks via min_tier.
+    entropyTierParticipantAligned = 2,
+
+    /// Validator commit/reveal entropy whose sidecar set passed the
+    /// active-validator-view quorum alignment gate.
+    entropyTierValidatorQuorum = 3,
+
+    /// Validator commit/reveal entropy with reveals from every validator in
+    /// the ledger-anchored active view. Any missing active validator downgrades
+    /// the tier, so hooks can require this to fail closed on selective
+    /// withholding.
+    entropyTierValidatorFull = 4,
+};
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/ExportLimits.h

@@ -0,0 +1,53 @@
+#ifndef RIPPLE_PROTOCOL_EXPORT_LIMITS_H_INCLUDED
+#define RIPPLE_PROTOCOL_EXPORT_LIMITS_H_INCLUDED
+
+#include <cstddef>
+#include <cstdint>
+
+namespace ripple {
+
+// Export system caps.
+//
+// These limits bound the DoS surface of the export signature system:
+// - Each pending export requires every validator to sign it every round
+//   (sign-once, attach once via TMProposeSet)
+// - Inbound signature processing involves crypto verification per sig
+// - The open-ledger cap (maxPendingExports) is the root constraint;
+//   signing throughput and inbound processing are transitively bounded by it
+struct ExportLimits
+{
+    // Maximum exports a single hook execution may produce. Hook API ABI
+    // constant hook_api::max_export must stay equal.
+    static constexpr std::uint8_t maxExportsPerHook = 2;
+
+    // Maximum pending export transactions in an open/apply ledger.
+    // Hook-emitted export backlog drains into the open ledger at this cap.
+    // This transitively caps:
+    //   - signatures per TMProposeSet message (1 per pending export)
+    //   - inbound proposal signature processing (clamped to this)
+    //   - validator signing work per round
+    static constexpr std::uint8_t maxPendingExports = 8;
+
+    // Maximum number of ledgers a pending export may retry before its
+    // mandatory LastLedgerSequence expires. This bounds validator signing work
+    // for both hook-emitted and user-submitted exports.
+    static constexpr std::uint32_t maxRetryLedgers = 5;
+
+    // Maximum byte length of a single export-signature wire blob:
+    //   txHash(32) + validator pubkey(33) + multisign signature(<= 72).
+    // A fully-canonical secp256k1 signature is at most 72 bytes (ed25519 is
+    // 64), so 137 is the true upper bound for a well-formed entry. The proposal
+    // ingress path hashes these blobs BEFORE the proposal signature is
+    // verified, so bounding the per-blob size caps pre-auth hashing/copy work
+    // (DoS).
+    static constexpr std::size_t maxExportSignatureBytes = 32 + 33 + 72;
+
+    // Export-signature sidecar leaves wrap one export-signature blob in an
+    // STObject envelope. Keep this comfortably above the canonical encoding
+    // while bounding fetched, peer-supplied leaf bytes before parse/hash work.
+    static constexpr std::size_t maxExportSignatureSidecarBytes = 256;
+};
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/Feature.h

@@ -33,35 +33,39 @@
  *
  * Steps required to add new features to the code:
  *
- * 1) In this file, increment `numFeatures` and add a uint256 declaration
- *    for the feature at the bottom
- * 2) Add a uint256 definition for the feature to the corresponding source
- *    file (Feature.cpp). Use `registerFeature` to create the feature with
- *    the feature's name, `Supported::no`, and `VoteBehavior::DefaultNo`. This
- *    should be the only place the feature's name appears in code as a string.
- * 3) Use the uint256 as the parameter to `view.rules.enabled()` to
- *    control flow into new code that this feature limits.
- * 4) If the feature development is COMPLETE, and the feature is ready to be
- *    SUPPORTED, change the `registerFeature` parameter to Supported::yes.
- * 5) When the feature is ready to be ENABLED, change the `registerFeature`
- *    parameter to `VoteBehavior::DefaultYes`.
- * In general, any newly supported amendments (`Supported::yes`) should have
- * a `VoteBehavior::DefaultNo` for at least one full release cycle. High
- * priority bug fixes can be an exception to this rule of thumb.
+ * 1) Add the appropriate XRPL_FEATURE or XRPL_FIX macro definition for the
+ *    feature to features.macro with the feature's name, `Supported::no`, and
+ *    `VoteBehavior::DefaultNo`.
+ *
+ * 2) Use the generated variable name as the parameter to `view.rules.enabled()`
+ *    to control flow into new code that this feature limits. (featureName or
+ *    fixName)
+ *
+ * 3) If the feature development is COMPLETE, and the feature is ready to be
+ *    SUPPORTED, change the macro parameter in features.macro to Supported::yes.
+ *
+ * 4) In general, any newly supported amendments (`Supported::yes`) should have
+ *    a `VoteBehavior::DefaultNo` indefinitely so that external governance can
+ *    make the decision on when to activate it. High priority bug fixes can be
+ *    an exception to this rule. In such cases, ensure the fix has been
+ *    clearly communicated to the community using appropriate channels,
+ *    then change the macro parameter in features.macro to
+ *    `VoteBehavior::DefaultYes`. The communication process is beyond
+ *    the scope of these instructions.
+ *
  *
  * When a feature has been enabled for several years, the conditional code
  * may be removed, and the feature "retired". To retire a feature:
- * 1) Remove the uint256 declaration from this file.
- * 2) MOVE the uint256 definition in Feature.cpp to the "retired features"
- *    section at the end of the file.
- * 3) CHANGE the name of the variable to start with "retired".
- * 4) CHANGE the parameters of the `registerFeature` call to `Supported::yes`
- *    and `VoteBehavior::DefaultNo`.
+ *
+ * 1) MOVE the macro definition in features.macro to the "retired features"
+ *    section at the end of the file, and change the macro to XRPL_RETIRE.
+ *
  * The feature must remain registered and supported indefinitely because it
- * still exists in the ledger, but there is no need to vote for it because
- * there's nothing to vote for. If it is removed completely from the code, any
- * instances running that code will get amendment blocked. Removing the
- * feature from the ledger is beyond the scope of these instructions.
+ * may exist in the Amendments object on ledger. There is no need to vote
+ * for it because there's nothing to vote for. If the feature definition is
+ * removed completely from the code, any instances running that code will get
+ * amendment blocked. Removing the feature from the ledger is beyond the scope
+ * of these instructions.
  *
  */
 
@@ -76,11 +80,32 @@ allAmendments();
 
 namespace detail {
 
+#pragma push_macro("XRPL_FEATURE")
+#undef XRPL_FEATURE
+#pragma push_macro("XRPL_FIX")
+#undef XRPL_FIX
+#pragma push_macro("XRPL_RETIRE")
+#undef XRPL_RETIRE
+
+#define XRPL_FEATURE(name, supported, vote) +1
+#define XRPL_FIX(name, supported, vote) +1
+#define XRPL_RETIRE(name) +1
+
 // This value SHOULD be equal to the number of amendments registered in
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures = 116;
+static constexpr std::size_t numFeatures =
+    (0 +
+#include <xrpl/protocol/detail/features.macro>
+    );
+
+#undef XRPL_RETIRE
+#pragma pop_macro("XRPL_RETIRE")
+#undef XRPL_FIX
+#pragma pop_macro("XRPL_FIX")
+#undef XRPL_FEATURE
+#pragma pop_macro("XRPL_FEATURE")
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated
@@ -320,12 +345,17 @@ foreachFeature(FeatureBitset bs, F&& f)
 #undef XRPL_FEATURE
 #pragma push_macro("XRPL_FIX")
 #undef XRPL_FIX
+#pragma push_macro("XRPL_RETIRE")
+#undef XRPL_RETIRE
 
 #define XRPL_FEATURE(name, supported, vote) extern uint256 const feature##name;
 #define XRPL_FIX(name, supported, vote) extern uint256 const fix##name;
+#define XRPL_RETIRE(name)
 
 #include <xrpl/protocol/detail/features.macro>
 
+#undef XRPL_RETIRE
+#pragma pop_macro("XRPL_RETIRE")
 #undef XRPL_FIX
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE

include/xrpl/protocol/HashPrefix.h

@@ -96,6 +96,21 @@ enum class HashPrefix : std::uint32_t {
 
     /** Credentials signature */
     credential = detail::make_hash_prefix('C', 'R', 'D'),
+
+    /** consensus extension sidecar object */
+    sidecar = detail::make_hash_prefix('S', 'C', 'R'),
+
+    /** consensus diagnostic observed participant set */
+    observedParticipants = detail::make_hash_prefix('O', 'B', 'P'),
+
+    /** consensus-bound fallback entropy digest (Tier 1: derived from
+        already-agreed round inputs when no agreed reveal set reaches an
+        accepted validator-participant tier; never to be confused with
+        validator entropy) */
+    entropyFallback = detail::make_hash_prefix('E', 'F', 'B'),
+
+    /** consensus entropy transaction-ordering salt */
+    entropyTxnOrder = detail::make_hash_prefix('E', 'T', 'O'),
 };
 
 template <class Hasher>

include/xrpl/protocol/Import.h

@@ -454,6 +454,15 @@ getVLInfo(Json::Value const& xpop, beast::Journal const& j)
             << "Import: unl blob was not valid json (after base64 decoding)";
         return {};
     }
+    auto const isNonNegativeUInt = [](Json::Value const& value) {
+        return value.isUInt() || (value.isInt() && value.asInt() >= 0);
+    };
+    if (!list.isMember(jss::sequence) ||
+        !isNonNegativeUInt(list[jss::sequence]))
+    {
+        JLOG(j.warn()) << "Import: unl blob sequence was missing or negative";
+        return {};
+    }
     auto const sequence = list[jss::sequence].asUInt();
     auto const m = deserializeManifest(base64_decode(
         xpop[jss::validation][jss::unl][jss::manifest].asString()));

include/xrpl/protocol/Indexes.h

@@ -62,6 +62,9 @@ emittedDir() noexcept;
 Keylet
 emittedTxn(uint256 const& id) noexcept;
 
+Keylet
+shadowTicket(AccountID const& account, std::uint32_t ticketSeq) noexcept;
+
 Keylet
 hookDefinition(uint256 const& hash) noexcept;
 
@@ -118,6 +121,10 @@ negativeUNL() noexcept;
 Keylet const&
 UNLReport() noexcept;
 
+/** The (fixed) index of the object containing consensus-derived entropy. */
+Keylet const&
+consensusEntropy() noexcept;
+
 /** The beginning of an order book */
 struct book_t
 {

include/xrpl/protocol/Protocol.h

@@ -43,6 +43,19 @@ std::size_t constexpr txMinSizeBytes = 10;
 /** Largest legal byte size of a transaction. */
 std::size_t constexpr txMaxSizeBytes = megabytes(1);
 
+/** Largest network ID whose transactions retain the legacy canonical form.
+
+    Transactions on these networks must omit sfNetworkID. Transactions on
+    networks with larger IDs must include sfNetworkID matching the network.
+ */
+std::uint32_t constexpr maxNetworkIDWithoutTxField = 1024;
+
+constexpr bool
+requiresTxNetworkID(std::uint32_t networkID)
+{
+    return networkID > maxNetworkIDWithoutTxField;
+}
+
 /** The maximum number of unfunded offers to delete at once */
 std::size_t constexpr unfundedOfferRemoveLimit = 1000;
 

include/xrpl/protocol/SidecarType.h

@@ -0,0 +1,21 @@
+#ifndef RIPPLE_PROTOCOL_SIDECAR_TYPE_H_INCLUDED
+#define RIPPLE_PROTOCOL_SIDECAR_TYPE_H_INCLUDED
+
+#include <cstdint>
+
+namespace ripple {
+
+/// Discriminator for sidecar set entries (SHAMap leaves used for
+/// consensus extension data: RNG commit/reveal, export signatures).
+///
+/// Stored in sfSidecarType (UINT8) on each STObject entry.
+/// Makes sidecar sets self-describing — no content-sniffing needed.
+enum SidecarType : std::uint8_t {
+    sidecarRngCommit = 1,
+    sidecarRngReveal = 2,
+    sidecarExportSig = 3,
+};
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/TER.h

@@ -68,7 +68,10 @@ enum TELcodes : TERUnderlyingType {
     telNON_LOCAL_EMITTED_TXN,
     telIMPORT_VL_KEY_NOT_RECOGNISED,
     telCAN_NOT_QUEUE_IMPORT,
+    // Keep test-only sentinels before appended branch-local TEL codes so their
+    // numeric values do not move.
     telENV_RPC_FAILED,
+    telSHADOW_TICKET_REQUIRED,
 };
 
 //------------------------------------------------------------------------------
@@ -137,6 +140,7 @@ enum TEMcodes : TERUnderlyingType {
     temXCHAIN_BRIDGE_NONDOOR_OWNER,
     temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT,
     temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT,
+    temXCHAIN_TOO_MANY_ATTESTATIONS,  // RESERVED - not used
 
     temHOOK_DATA_TOO_LARGE,
     temEMPTY_DID,
@@ -233,8 +237,10 @@ enum TERcodes : TERUnderlyingType {
     terQUEUED,       // Transaction is being held in TxQ until fee drops
     terPRE_TICKET,   // Ticket is not yet in ledger but might be on its way
     terNO_AMM,       // AMM doesn't exist for the asset pair
-    terNO_HOOK       // Transaction requires a non-existent hook definition
+    terNO_HOOK,      // Transaction requires a non-existent hook definition
                      // (referenced by sfHookHash)
+    terRETRY_EXPORT  // Export does not yet have enough validator signatures.
+                     // Retained in retriable set for next ledger.
 };
 
 //------------------------------------------------------------------------------
@@ -362,7 +368,7 @@ enum TECcodes : TERUnderlyingType {
     tecARRAY_TOO_LARGE = 197,
     tecLOCKED = 198,
     tecBAD_CREDENTIALS = 199,
-    tecINVALID_HOOK_API_VERSION = 200,
+    tecEXPORT_EXPIRED = 200,
     tecLAST_POSSIBLE_ENTRY = 255,
 };
 

include/xrpl/protocol/TxFlags.h

@@ -274,6 +274,13 @@ enum BridgeModifyFlags : uint32_t {
     tfClearAccountCreateAmount = 0x00010000,
 };
 constexpr std::uint32_t tfBridgeModifyMask = ~(tfUniversal | tfClearAccountCreateAmount);
+
+// ConsensusEntropy flags (used on ttCONSENSUS_ENTROPY SHAMap entries):
+enum ConsensusEntropyFlags : uint32_t {
+    tfEntropyCommit = 0x00000001,  // entry is a commitment in commitSet
+    tfEntropyReveal = 0x00000002,  // entry is a reveal in entropySet
+};
+// flag=0 (no tfEntropyCommit/tfEntropyReveal) = final injected pseudo-tx
 // clang-format on
 
 }  // namespace ripple

include/xrpl/protocol/TxMeta.h

@@ -140,6 +140,12 @@ public:
         mHookEmissions = hookEmissions;
     }
 
+    void
+    setExportResult(STObject const& exportResult)
+    {
+        mExportResult = exportResult;
+    }
+
     bool
     hasHookExecutions() const
     {
@@ -152,6 +158,12 @@ public:
         return static_cast<bool>(mHookEmissions);
     }
 
+    bool
+    hasExportResult() const
+    {
+        return static_cast<bool>(mExportResult);
+    }
+
     STAmount
     getDeliveredAmount() const
     {
@@ -176,6 +188,7 @@ private:
     std::optional<STAmount> mDelivered;
     std::optional<STArray> mHookExecutions;
     std::optional<STArray> mHookEmissions;
+    std::optional<STObject> mExportResult;
 
     STArray mNodes;
 };

include/xrpl/protocol/detail/features.macro

@@ -23,6 +23,9 @@
 #if !defined(XRPL_FIX)
 #error "undefined macro: XRPL_FIX"
 #endif
+#if !defined(XRPL_RETIRE)
+#error "undefined macro: XRPL_RETIRE"
+#endif
 
 // clang-format off
 
@@ -31,7 +34,10 @@
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
 
-XRPL_FEATURE(JSHooks,                    Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (HookMap,                    Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FIX    (GuardDepth32,               Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(NamedHooks,                 Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(IOURewardClaim,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (IOULockedBalanceInvariant,  Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (ImportIssuer,               Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(HookAPISerializedType240,   Supported::yes, VoteBehavior::DefaultNo)
@@ -55,18 +61,20 @@ XRPL_FIX    (FillOrKill,                 Supported::yes, VoteBehavior::DefaultYe
 XRPL_FEATURE(DID,                        Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (DisallowIncomingV1,         Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(XChainBridge,               Supported::no,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(AMM,                        Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(AMM,                        Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (ReducedOffersV1,            Supported::yes, VoteBehavior::DefaultYes)
-XRPL_FEATURE(HooksUpdate2,               Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FEATURE(HookOnV2,                   Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FIX    (HookAPI20251128,            Supported::yes, VoteBehavior::DefaultYes);
-XRPL_FIX    (CronStacking,               Supported::yes, VoteBehavior::DefaultYes);
-XRPL_FEATURE(ExtendedHookState,          Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultYes);
-XRPL_FEATURE(Cron,                       Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FEATURE(IOUIssuerWeakTSH,           Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo);
-XRPL_FIX    (ProvisionalDoubleThreading, Supported::yes, VoteBehavior::DefaultYes);
+XRPL_FEATURE(HooksUpdate2,               Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(HookOnV2,                   Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(Export,                     Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(ConsensusEntropy,           Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (HookAPI20251128,            Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FIX    (CronStacking,               Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FEATURE(ExtendedHookState,          Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultYes)
+XRPL_FEATURE(Cron,                       Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(IOUIssuerWeakTSH,           Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (ProvisionalDoubleThreading, Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(Clawback,                   Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (RewardClaimFlags,           Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FEATURE(HookCanEmit,                Supported::yes, VoteBehavior::DefaultNo)
@@ -150,4 +158,24 @@ XRPL_FIX    (NFTokenDirV1,          Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(NonFungibleTokensV1,   Supported::yes, VoteBehavior::Obsolete)
 XRPL_FEATURE(CryptoConditionsSuite, Supported::yes, VoteBehavior::Obsolete)
 
+// The following amendments have been active for at least two years. Their
+// pre-amendment code has been removed and the identifiers are deprecated.
+// All known amendments and amendments that may appear in a validated
+// ledger must be registered either here or above with the "active" amendments
+XRPL_RETIRE(MultiSign)
+XRPL_RETIRE(TrustSetAuth)
+XRPL_RETIRE(FeeEscalation)
+XRPL_RETIRE(PayChan)
+XRPL_RETIRE(CryptoConditions)
+XRPL_RETIRE(TickSize)
+XRPL_RETIRE(fix1368)
+XRPL_RETIRE(Escrow)
+XRPL_RETIRE(fix1373)
+XRPL_RETIRE(EnforceInvariants)
+XRPL_RETIRE(SortedDirectories)
+XRPL_RETIRE(fix1201)
+XRPL_RETIRE(fix1512)
+XRPL_RETIRE(fix1523)
+XRPL_RETIRE(fix1528)
+
 // clang-format on

include/xrpl/protocol/detail/ledger_entries.macro

@@ -93,7 +93,7 @@ LEDGER_ENTRY(ltCHECK, 0x0043, Check, check, ({
 */
 LEDGER_ENTRY(ltHOOK_DEFINITION, 'D', HookDefinition, hook_definition, ({
     {sfHookHash,             soeREQUIRED},
-    {sfHookOn,               soeREQUIRED},
+    {sfHookOn,               soeOPTIONAL},
     {sfHookOnIncoming,       soeOPTIONAL},
     {sfHookOnOutgoing,       soeOPTIONAL},
     {sfHookCanEmit,          soeOPTIONAL},
@@ -223,6 +223,23 @@ LEDGER_ENTRY(ltURI_TOKEN, 0x0055, URIToken, uri_token, ({
     {sfPreviousTxnLgrSeq,    soeREQUIRED},
 }))
 
+/** The ledger object which stores consensus-derived entropy.
+
+    \note This is a singleton: only one such object exists in the ledger.
+
+    \sa keylet::consensusEntropy
+ */
+LEDGER_ENTRY_DUPLICATE(ltCONSENSUS_ENTROPY, 0x0058, ConsensusEntropy, consensus_entropy, ({
+    {sfDigest,               soeREQUIRED},
+    {sfEntropyCount,         soeREQUIRED},
+    {sfEntropyDenominator,   soeREQUIRED},
+    {sfEntropyContributors,  soeREQUIRED},
+    {sfEntropyTier,          soeREQUIRED},
+    {sfLedgerSequence,       soeREQUIRED},
+    {sfPreviousTxnID,        soeREQUIRED},
+    {sfPreviousTxnLgrSeq,    soeREQUIRED},
+}))
+
 /** A ledger object which describes an account.
 
     \sa keylet::account
@@ -396,6 +413,8 @@ LEDGER_ENTRY(ltRIPPLE_STATE, 0x0072, RippleState, state, ({
     {sfHighQualityOut,       soeOPTIONAL},
     {sfLockedBalance,        soeOPTIONAL},
     {sfLockCount,            soeOPTIONAL},
+    {sfHighReward,           soeOPTIONAL},
+    {sfLowReward,            soeOPTIONAL},
 }))
 
 /** The ledger object which lists the network's fee settings.
@@ -590,6 +609,24 @@ LEDGER_ENTRY(ltDID, 0x008D, DID, did, ({
     {sfPreviousTxnLgrSeq,    soeREQUIRED},
 }))
 
+//@@start shadow-ticket-ledger-entry
+/** A live callback latch for an exported ticket transaction.
+
+    Created when a transaction is exported. Consumed when
+    proof-of-execution is imported back. Account-owned (pays reserve).
+    This is not a permanent replay tombstone; hook callbacks that move
+    value must still deduplicate their business action.
+
+    \sa keylet::shadowTicket
+ */
+LEDGER_ENTRY(ltSHADOW_TICKET, 0x5374, ShadowTicket, shadow_ticket, ({
+    {sfAccount,              soeREQUIRED},
+    {sfTicketSequence,       soeREQUIRED},
+    {sfTransactionHash,      soeREQUIRED},
+    {sfLedgerSequence,       soeREQUIRED},
+    {sfOwnerNode,            soeREQUIRED},
+}))
+//@@end shadow-ticket-ledger-entry
+
 #undef EXPAND
 #undef LEDGER_ENTRY_DUPLICATE
-

include/xrpl/protocol/detail/sfields.macro

@@ -42,6 +42,8 @@ TYPED_SFIELD(sfTickSize,                 UINT8,     16)
 TYPED_SFIELD(sfUNLModifyDisabling,       UINT8,     17)
 TYPED_SFIELD(sfHookResult,               UINT8,     18)
 TYPED_SFIELD(sfWasLockingChainSend,      UINT8,     19)
+TYPED_SFIELD(sfSidecarType,              UINT8,     20)
+TYPED_SFIELD(sfEntropyTier,              UINT8,     21)
 
 // 16-bit integers (common)
 TYPED_SFIELD(sfLedgerEntryType,          UINT16,     1, SField::sMD_Never)
@@ -59,6 +61,9 @@ TYPED_SFIELD(sfHookExecutionIndex,       UINT16,    19)
 TYPED_SFIELD(sfHookApiVersion,           UINT16,    20)
 TYPED_SFIELD(sfHookStateScale,           UINT16,    21)
 TYPED_SFIELD(sfLedgerFixType,            UINT16,    22)
+TYPED_SFIELD(sfHookExportCount,          UINT16,    98)
+TYPED_SFIELD(sfEntropyCount,             UINT16,    99)
+TYPED_SFIELD(sfEntropyDenominator,       UINT16,   100)
 
 // 32-bit integers (common)
 TYPED_SFIELD(sfNetworkID,                UINT32,     1)
@@ -123,6 +128,7 @@ TYPED_SFIELD(sfImportSequence,           UINT32,    97)
 TYPED_SFIELD(sfRewardTime,               UINT32,    98)
 TYPED_SFIELD(sfRewardLgrFirst,           UINT32,    99)
 TYPED_SFIELD(sfRewardLgrLast,            UINT32,   100)
+TYPED_SFIELD(sfCancelTicketSequence,     UINT32,   101)
 
 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -210,6 +216,7 @@ TYPED_SFIELD(sfOfferID,                  UINT256,   34)
 TYPED_SFIELD(sfEscrowID,                 UINT256,   35)
 TYPED_SFIELD(sfURITokenID,               UINT256,   36)
 TYPED_SFIELD(sfDomainID,                 UINT256,   37)
+TYPED_SFIELD(sfExportSignatureHash,      UINT256,   38)
 TYPED_SFIELD(sfHookOnOutgoing,           UINT256,   93)
 TYPED_SFIELD(sfHookOnIncoming,           UINT256,   94)
 TYPED_SFIELD(sfCron,                     UINT256,   95)
@@ -257,6 +264,7 @@ TYPED_SFIELD(sfPrice,                    AMOUNT,    28)
 TYPED_SFIELD(sfSignatureReward,          AMOUNT,    29)
 TYPED_SFIELD(sfMinAccountCreateAmount,   AMOUNT,    30)
 TYPED_SFIELD(sfLPTokenBalance,           AMOUNT,    31)
+TYPED_SFIELD(sfTrustLineRewardAccumulator,AMOUNT,   99)
 
 // variable length (common)
 TYPED_SFIELD(sfPublicKey,                VL,         1)
@@ -292,6 +300,8 @@ TYPED_SFIELD(sfAssetClass,               VL,        29)
 TYPED_SFIELD(sfProvider,                 VL,        30)
 TYPED_SFIELD(sfMPTokenMetadata,          VL,        31)
 TYPED_SFIELD(sfCredentialType,           VL,        32)
+TYPED_SFIELD(sfEntropyContributors,      VL,        33)
+TYPED_SFIELD(sfHookName,                 VL,        97)
 TYPED_SFIELD(sfRemarkValue,              VL,        98)
 TYPED_SFIELD(sfRemarkName,               VL,        99)
 
@@ -340,6 +350,7 @@ TYPED_SFIELD(sfLockingChainIssue,        ISSUE,      1)
 TYPED_SFIELD(sfIssuingChainIssue,        ISSUE,      2)
 TYPED_SFIELD(sfAsset,                    ISSUE,      3)
 TYPED_SFIELD(sfAsset2,                   ISSUE,      4)
+TYPED_SFIELD(sfClaimCurrency,            ISSUE,      5)
 
 // bridge
 TYPED_SFIELD(sfXChainBridge,             XCHAIN_BRIDGE, 1)
@@ -379,6 +390,7 @@ UNTYPED_SFIELD(sfXChainClaimAttestationCollectionElement, OBJECT, 30)
 UNTYPED_SFIELD(sfXChainCreateAccountAttestationCollectionElement, OBJECT, 31)
 UNTYPED_SFIELD(sfPriceData,              OBJECT,    32)
 UNTYPED_SFIELD(sfCredential,             OBJECT,    33)
+UNTYPED_SFIELD(sfExportedTxn,            OBJECT,    90)
 UNTYPED_SFIELD(sfAmountEntry,            OBJECT,    91)
 UNTYPED_SFIELD(sfMintURIToken,           OBJECT,    92)
 UNTYPED_SFIELD(sfHookEmission,           OBJECT,    93)
@@ -386,6 +398,9 @@ UNTYPED_SFIELD(sfImportVLKey,            OBJECT,    94)
 UNTYPED_SFIELD(sfActiveValidator,        OBJECT,    95)
 UNTYPED_SFIELD(sfGenesisMint,            OBJECT,    96)
 UNTYPED_SFIELD(sfRemark,                 OBJECT,    97)
+UNTYPED_SFIELD(sfHighReward,             OBJECT,    98)
+UNTYPED_SFIELD(sfLowReward,              OBJECT,    99)
+UNTYPED_SFIELD(sfExportResult,           OBJECT,    100)
 
 // array of objects (common)
 // ARRAY/1 is reserved for end of array

include/xrpl/protocol/detail/transactions.macro

@@ -500,6 +500,17 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 72, PermissionedDomainDelete, ({
     {sfDomainID, soeREQUIRED},
 }))
 
+//@@start export-transaction-types
+/* User-submittable export: creates a cross-chain transaction for
+   validator signing. Retries via terRETRY_EXPORT until quorum.
+   Also supports shadow ticket cancellation via sfCancelTicketSequence.
+   At least one of sfExportedTxn or sfCancelTicketSequence must be present. */
+TRANSACTION(ttEXPORT, 91, Export, ({
+    {sfExportedTxn, soeOPTIONAL},
+    {sfCancelTicketSequence, soeOPTIONAL},
+}))
+//@@end export-transaction-types
+
 /* A pseudo-txn alarm signal for invoking a hook, emitted by validators after alarm set conditions are met */
 TRANSACTION(ttCRON, 92, Cron, ({
     {sfOwner, soeREQUIRED},
@@ -550,6 +561,7 @@ TRANSACTION(ttIMPORT, 97, Import, ({
   * from a specified hook */
 TRANSACTION(ttCLAIM_REWARD, 98, ClaimReward, ({
     {sfIssuer, soeOPTIONAL},
+    {sfClaimCurrency, soeOPTIONAL},
 }))
 
 /** This transaction invokes a hook, providing arbitrary data. Essentially as a 0 drop payment. **/
@@ -605,3 +617,17 @@ TRANSACTION(ttUNL_REPORT, 104, UNLReport, ({
     {sfActiveValidator, soeOPTIONAL},
     {sfImportVLKey, soeOPTIONAL},
 }))
+
+TRANSACTION(ttCONSENSUS_ENTROPY, 105, ConsensusEntropy, ({
+    {sfLedgerSequence, soeREQUIRED},
+    {sfDigest, soeREQUIRED},
+    {sfEntropyCount, soeREQUIRED},
+    {sfEntropyDenominator, soeREQUIRED},
+    {sfEntropyContributors, soeREQUIRED},
+    {sfEntropyTier, soeREQUIRED},
+}))
+
+TRANSACTION(ttEXPORT_SIGNATURES, 106, ExportSignatures, ({
+    {sfLedgerSequence, soeREQUIRED},
+    {sfTransactionHash, soeREQUIRED},
+}))

include/xrpl/protocol/jss.h

@@ -76,6 +76,7 @@ JSS(Holder);              // field.
 JSS(HookApiVersion);      // field
 JSS(HookCanEmit);         // field
 JSS(HookHash);            // field
+JSS(HookName);            // field
 JSS(HookNamespace);       // field
 JSS(HookOn);              // field
 JSS(HookOnIncoming);      // field

include/xrpl/resource/detail/Logic.h

@@ -109,14 +109,22 @@ public:
     Consumer
     newInboundEndpoint(beast::IP::Endpoint const& address)
     {
+        //@@start rng-local-testnet-resource-bucket
+        // Inbound connections from the same IP normally share one
+        // resource bucket (port stripped) for DoS protection.  For
+        // loopback addresses, preserve the port so local testnet nodes
+        // each get their own bucket instead of all sharing one.
+        auto const key = is_loopback(address) ? address : address.at_port(0);
+        //@@end rng-local-testnet-resource-bucket
+
         Entry* entry(nullptr);
 
         {
             std::lock_guard _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(kindInbound, address.at_port(0)),  // Key
-                std::make_tuple(m_clock.now()));                   // Entry
+                std::make_tuple(kindInbound, key),
+                std::make_tuple(m_clock.now()));
 
             entry = &resultIt->second;
             entry->key = &resultIt->first;

release-builder.sh

@@ -11,11 +11,11 @@ echo "START BUILDING (HOST)"
 echo "Cleaning previously built binary"
 rm -f release-build/xahaud
 
-BUILD_CORES=$(echo "scale=0 ; `nproc` / 1.337" | bc)
+BUILD_CORES=$(echo "scale=0 ; $(nproc) / 1.337" | bc)
 
 if [[ "$GITHUB_REPOSITORY" == "" ]]; then
   #Default
-  BUILD_CORES=${BUILD_CORES:-8} 
+  BUILD_CORES=${BUILD_CORES:-8}
 fi
 
 # Ensure still works outside of GH Actions by setting these to /dev/null
@@ -31,21 +31,19 @@ echo "-- GITHUB_SHA:        $GITHUB_SHA"
 echo "-- GITHUB_RUN_NUMBER: $GITHUB_RUN_NUMBER"
 echo "-- CONTAINER_NAME:    $CONTAINER_NAME"
 
-which docker 2> /dev/null 2> /dev/null
-if [ "$?" -eq "1" ]
-then
+which docker 2>/dev/null 2>/dev/null
+if [ "$?" -eq "1" ]; then
   echo 'Docker not found. Install it first.'
   exit 1
 fi
 
-stat .git 2> /dev/null 2> /dev/null
-if [ "$?" -eq "1" ]
-then
+stat .git 2>/dev/null 2>/dev/null
+if [ "$?" -eq "1" ]; then
   echo 'Run this inside the source directory. (.git dir not found).'
   exit 1
 fi
 
-STATIC_CONTAINER=$(docker ps -a | grep $CONTAINER_NAME |wc -l)
+STATIC_CONTAINER=$(docker ps -a | grep $CONTAINER_NAME | wc -l)
 
 CACHE_VOLUME_NAME="xahau-release-builder-cache"
 
@@ -57,13 +55,14 @@ if false; then
   docker stop $CONTAINER_NAME
 else
   echo "No static container, build on temp container"
-  rm -rf release-build;
-  mkdir -p release-build;
+  rm -rf release-build
+  mkdir -p release-build
 
   docker volume create $CACHE_VOLUME_NAME
 
   # Create inline Dockerfile with environment setup for build-full.sh
-  DOCKERFILE_CONTENT=$(cat <<'DOCKERFILE_EOF'
+  DOCKERFILE_CONTENT=$(
+    cat <<'DOCKERFILE_EOF'
 FROM ghcr.io/phusion/holy-build-box:4.0.1-amd64
 
 ARG BUILD_CORES=8
@@ -218,7 +217,7 @@ RUN /hbb_exe/activate-exec bash -c "ccache -M 100G && \
     ln -s ../../bin/ccache /usr/lib64/ccache/c++"
 
 DOCKERFILE_EOF
-)
+  )
 
   # Build custom Docker image
   IMAGE_NAME="xahaud-builder:latest"
@@ -228,14 +227,14 @@ DOCKERFILE_EOF
   if [[ "$GITHUB_REPOSITORY" == "" ]]; then
     # Non GH, local building
     echo "Non-GH runner, local building, temp container"
-    docker run -i --user 0:$(id -g) --rm -v /data/builds:/data/builds -v `pwd`:/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
+    docker run -i --user 0:$(id -g) --rm -v /data/builds:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
   else
     # GH Action, runner
     echo "GH Action, runner, clean & re-create create persistent container"
     docker rm -f $CONTAINER_NAME
-    echo "echo 'Stopping container: $CONTAINER_NAME'" >> "$JOB_CLEANUP_SCRIPT"
-    echo "docker stop --time=15 \"$CONTAINER_NAME\" || echo 'Failed to stop container or container not running'" >> "$JOB_CLEANUP_SCRIPT"
-    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v /data/builds:/data/builds -v `pwd`:/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash
+    echo "echo 'Stopping container: $CONTAINER_NAME'" >>"$JOB_CLEANUP_SCRIPT"
+    echo "docker stop --time=15 \"$CONTAINER_NAME\" || echo 'Failed to stop container or container not running'" >>"$JOB_CLEANUP_SCRIPT"
+    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v /data/builds:/data/builds -v $(pwd):/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash
     docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
     docker stop $CONTAINER_NAME
   fi

src/libxrpl/basics/Log.cpp

@@ -31,6 +31,7 @@
 #include <cassert>
 #include <cstring>
 #include <ctime>
+#include <exception>
 #include <fstream>
 #include <functional>
 #include <iostream>
@@ -351,9 +352,18 @@ Logs::format(
 
     if (useLocalTime)
     {
-        auto now = std::chrono::system_clock::now();
-        auto local = date::make_zoned(date::current_zone(), now);
-        output = date::format(fmt, local);
+        try
+        {
+            auto now = std::chrono::system_clock::now();
+            auto local = date::make_zoned(date::current_zone(), now);
+            output = date::format(fmt, local);
+        }
+        catch (std::exception const&)
+        {
+            // Enhanced logging should not make startup fatal if tzdb lookup is
+            // unavailable or misconfigured. Fall back to UTC formatting.
+            output = date::format(fmt, std::chrono::system_clock::now());
+        }
     }
     else
     {

src/libxrpl/protocol/AMMCore.cpp

@@ -66,7 +66,7 @@ invalidAMMAsset(
     Issue const& issue,
     std::optional<std::pair<Issue, Issue>> const& pair)
 {
-    if (badCurrency() == issue.currency)
+    if (isBadCurrency(issue.currency))
         return temBAD_CURRENCY;
     if (isXRP(issue) && issue.account.isNonZero())
         return temBAD_ISSUER;

src/libxrpl/protocol/Feature.cpp

@@ -250,12 +250,9 @@ FeatureCollections::registerFeature(
     Feature const* i = getByName(name);
     if (!i)
     {
-        // If this check fails, and you just added a feature, increase the
-        // numFeatures value in Feature.h
         check(
             features.size() < detail::numFeatures,
-            "More features defined than allocated. Adjust numFeatures in "
-            "Feature.h.");
+            "More features defined than allocated.");
 
         auto const f = sha512Half(Slice(name.data(), name.size()));
 
@@ -424,45 +421,26 @@ featureToName(uint256 const& f)
 #undef XRPL_FEATURE
 #pragma push_macro("XRPL_FIX")
 #undef XRPL_FIX
+#pragma push_macro("XRPL_RETIRE")
+#undef XRPL_RETIRE
 
 #define XRPL_FEATURE(name, supported, vote) \
     uint256 const feature##name = registerFeature(#name, supported, vote);
 #define XRPL_FIX(name, supported, vote) \
     uint256 const fix##name = registerFeature("fix" #name, supported, vote);
+#define XRPL_RETIRE(name)                                                     \
+    [[deprecated("The referenced amendment has been retired"), maybe_unused]] \
+    uint256 const retired##name = retireFeature(#name);
 
 #include <xrpl/protocol/detail/features.macro>
 
+#undef XRPL_RETIRE
+#pragma pop_macro("XRPL_RETIRE")
 #undef XRPL_FIX
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE
 #pragma pop_macro("XRPL_FEATURE")
 
-// clang-format off
-
-// The following amendments have been active for at least two years. Their
-// pre-amendment code has been removed and the identifiers are deprecated.
-// All known amendments and amendments that may appear in a validated
-// ledger must be registered either here or above with the "active" amendments
-[[deprecated("The referenced amendment has been retired"), maybe_unused]]
-uint256 const
-    retiredMultiSign         = retireFeature("MultiSign"),
-    retiredTrustSetAuth      = retireFeature("TrustSetAuth"),
-    retiredFeeEscalation     = retireFeature("FeeEscalation"),
-    retiredPayChan           = retireFeature("PayChan"),
-    retiredCryptoConditions  = retireFeature("CryptoConditions"),
-    retiredTickSize          = retireFeature("TickSize"),
-    retiredFix1368           = retireFeature("fix1368"),
-    retiredEscrow            = retireFeature("Escrow"),
-    retiredFix1373           = retireFeature("fix1373"),
-    retiredEnforceInvariants = retireFeature("EnforceInvariants"),
-    retiredSortedDirectories = retireFeature("SortedDirectories"),
-    retiredFix1201           = retireFeature("fix1201"),
-    retiredFix1512           = retireFeature("fix1512"),
-    retiredFix1523           = retireFeature("fix1523"),
-    retiredFix1528           = retireFeature("fix1528");
-
-// clang-format on
-
 // All of the features should now be registered, since variables in a cpp file
 // are initialized from top to bottom.
 //

src/libxrpl/protocol/Indexes.cpp

@@ -74,6 +74,7 @@ enum class LedgerNameSpace : std::uint16_t {
     HOOK_DEFINITION = 'D',
     EMITTED_TXN = 'E',
     EMITTED_DIR = 'F',
+    SHADOW_TICKET = 0x5374,  // St
     NFTOKEN_OFFER = 'q',
     NFTOKEN_BUY_OFFERS = 'h',
     NFTOKEN_SELL_OFFERS = 'i',
@@ -81,6 +82,7 @@ enum class LedgerNameSpace : std::uint16_t {
     IMPORT_VLSEQ = 'I',
     UNL_REPORT = 'R',
     CRON = 'L',
+    CONSENSUS_ENTROPY = 'X',
     AMM = 'A',
     BRIDGE = LEDGER_NAMESPACE2(0x01, 'H'),
     XCHAIN_CLAIM_ID = 'Q',
@@ -188,6 +190,15 @@ emittedTxn(uint256 const& id) noexcept
     return {ltEMITTED_TXN, indexHash(LedgerNameSpace::EMITTED_TXN, id)};
 }
 
+Keylet
+shadowTicket(AccountID const& account, std::uint32_t ticketSeq) noexcept
+{
+    return {
+        ltSHADOW_TICKET,
+        indexHash(
+            LedgerNameSpace::SHADOW_TICKET, account, std::uint32_t(ticketSeq))};
+}
+
 Keylet
 hook(AccountID const& id) noexcept
 {
@@ -546,6 +557,14 @@ cron(uint32_t timestamp, std::optional<AccountID> const& id)
     return {ltCRON, uint256::fromVoid(h)};
 }
 
+Keylet const&
+consensusEntropy() noexcept
+{
+    static Keylet const ret{
+        ltCONSENSUS_ENTROPY, indexHash(LedgerNameSpace::CONSENSUS_ENTROPY)};
+    return ret;
+}
+
 Keylet
 amm(Asset const& issue1, Asset const& issue2) noexcept
 {

src/libxrpl/protocol/InnerObjectFormats.cpp

@@ -78,6 +78,7 @@ InnerObjectFormats::InnerObjectFormats()
          {sfHookExecutionIndex, soeREQUIRED},
          {sfHookStateChangeCount, soeREQUIRED},
          {sfHookEmitCount, soeREQUIRED},
+         {sfHookExportCount, soeOPTIONAL},
          {sfFlags, soeOPTIONAL}});
 
     add(sfHookEmission.jsonName,
@@ -99,7 +100,7 @@ InnerObjectFormats::InnerObjectFormats()
          {sfHookOnOutgoing, soeOPTIONAL},
          {sfHookCanEmit, soeOPTIONAL},
          {sfHookApiVersion, soeOPTIONAL},
-         {sfFee, soeOPTIONAL},
+         {sfHookName, soeOPTIONAL},
          {sfFlags, soeOPTIONAL}});
 
     add(sfHookGrant.jsonName,
@@ -254,6 +255,24 @@ InnerObjectFormats::InnerObjectFormats()
             {sfIssuer, soeREQUIRED},
             {sfCredentialType, soeREQUIRED},
         });
+
+    add(sfHighReward.jsonName,
+        sfHighReward.getCode(),
+        {
+            {sfRewardLgrFirst, soeREQUIRED},
+            {sfRewardLgrLast, soeREQUIRED},
+            {sfRewardTime, soeREQUIRED},
+            {sfTrustLineRewardAccumulator, soeREQUIRED},
+        });
+
+    add(sfLowReward.jsonName,
+        sfLowReward.getCode(),
+        {
+            {sfRewardLgrFirst, soeREQUIRED},
+            {sfRewardLgrLast, soeREQUIRED},
+            {sfRewardTime, soeREQUIRED},
+            {sfTrustLineRewardAccumulator, soeREQUIRED},
+        });
 }
 
 InnerObjectFormats const&

src/libxrpl/protocol/Issue.cpp

@@ -111,7 +111,7 @@ issueFromJson(Json::Value const& v)
     }
 
     auto const currency = to_currency(curStr.asString());
-    if (currency == badCurrency() || currency == noCurrency())
+    if (isBadCurrency(currency) || currency == noCurrency())
     {
         Throw<Json::error>("issueFromJson currency must be a valid currency");
     }

src/libxrpl/protocol/STCurrency.cpp

@@ -103,7 +103,7 @@ currencyFromJson(SField const& name, Json::Value const& v)
     }
 
     auto const currency = to_currency(v.asString());
-    if (currency == badCurrency() || currency == noCurrency())
+    if (isBadCurrency(currency) || currency == noCurrency())
     {
         Throw<std::runtime_error>(
             "currencyFromJson currency must be a valid currency");

src/libxrpl/protocol/STTx.cpp

@@ -684,7 +684,8 @@ isPseudoTx(STObject const& tx)
 
     auto tt = safe_cast<TxType>(*t);
     return tt == ttAMENDMENT || tt == ttFEE || tt == ttUNL_MODIFY ||
-        tt == ttEMIT_FAILURE || tt == ttUNL_REPORT || tt == ttCRON;
+        tt == ttEMIT_FAILURE || tt == ttUNL_REPORT || tt == ttCRON ||
+        tt == ttCONSENSUS_ENTROPY || tt == ttEXPORT_SIGNATURES;
 }
 
 }  // namespace ripple

src/libxrpl/protocol/TER.cpp

@@ -124,7 +124,7 @@ transResults()
         MAKE_ERROR(tecARRAY_TOO_LARGE,               "Array is too large."),
         MAKE_ERROR(tecLOCKED,                        "Fund is locked."),
         MAKE_ERROR(tecBAD_CREDENTIALS,               "Bad credentials."),
-        MAKE_ERROR(tecINVALID_HOOK_API_VERSION,      "Invalid field for current hook API version."),
+        MAKE_ERROR(tecEXPORT_EXPIRED,                "Export expired without reaching signature quorum."),
 
         MAKE_ERROR(tefALREADY,                     "The exact transaction was already in this ledger."),
         MAKE_ERROR(tefBAD_ADD_AUTH,                "Not authorized to add account."),
@@ -173,6 +173,7 @@ transResults()
         MAKE_ERROR(telIMPORT_VL_KEY_NOT_RECOGNISED, "Import vl key was not recognized."),
         MAKE_ERROR(telCAN_NOT_QUEUE_IMPORT,   "Import transaction was not able to be directly applied and cannot be queued."),
         MAKE_ERROR(telENV_RPC_FAILED,         "Unit test RPC failure."),
+        MAKE_ERROR(telSHADOW_TICKET_REQUIRED, "The imported transaction uses a TicketSequence but no shadow ticket exists."),
 
         MAKE_ERROR(temMALFORMED,                 "Malformed transaction."),
         MAKE_ERROR(temBAD_AMM_TOKENS,            "Malformed: Invalid LPTokens."),
@@ -239,6 +240,7 @@ transResults()
         MAKE_ERROR(terPRE_TICKET,             "Ticket is not yet in ledger."),
         MAKE_ERROR(terNO_HOOK,                "No hook with that hash exists on the ledger."),
         MAKE_ERROR(terNO_AMM,                 "AMM doesn't exist for the asset pair."),
+        MAKE_ERROR(terRETRY_EXPORT,          "Export awaiting validator signatures."),
 
         MAKE_ERROR(tesSUCCESS,                "The transaction was applied. Only final in a validated ledger."),
         MAKE_ERROR(tesPARTIAL,                "The transaction was applied but should be submitted again until returning tesSUCCESS."),

src/libxrpl/protocol/TxFormats.cpp

@@ -48,6 +48,7 @@ TxFormats::TxFormats()
         {sfFirstLedgerSequence, soeOPTIONAL},
         {sfNetworkID, soeOPTIONAL},
         {sfHookParameters, soeOPTIONAL},
+        {sfHookName, soeOPTIONAL},
     };
 
 #pragma push_macro("UNWRAP")

src/libxrpl/protocol/TxMeta.cpp

@@ -49,6 +49,11 @@ TxMeta::TxMeta(
 
     if (obj.isFieldPresent(sfHookEmissions))
         setHookEmissions(obj.getFieldArray(sfHookEmissions));
+
+    if (obj.isFieldPresent(sfExportResult))
+        setExportResult(const_cast<STObject&>(obj)
+                            .getField(sfExportResult)
+                            .downcast<STObject>());
 }
 
 TxMeta::TxMeta(uint256 const& txid, std::uint32_t ledger, STObject const& obj)
@@ -75,6 +80,11 @@ TxMeta::TxMeta(uint256 const& txid, std::uint32_t ledger, STObject const& obj)
 
     if (obj.isFieldPresent(sfHookEmissions))
         setHookEmissions(obj.getFieldArray(sfHookEmissions));
+
+    if (obj.isFieldPresent(sfExportResult))
+        setExportResult(const_cast<STObject&>(obj)
+                            .getField(sfExportResult)
+                            .downcast<STObject>());
 }
 
 TxMeta::TxMeta(uint256 const& txid, std::uint32_t ledger, Blob const& vec)
@@ -245,6 +255,14 @@ TxMeta::getAsObject() const
     if (hasHookEmissions())
         metaData.setFieldArray(sfHookEmissions, getHookEmissions());
 
+    if (hasExportResult())
+    {
+        Serializer s;
+        mExportResult->add(s);
+        SerialIter sit(s.slice());
+        metaData.emplace_back(STObject(sit, sfExportResult));
+    }
+
     return metaData;
 }
 

src/quickjs/buffer-utils.c

@@ -1,820 +0,0 @@
-#include "defines.h"
-#include "char-utils.h"
-#include "buffer-utils.h"
-#include "utils.h"
-#ifdef _WIN32
-#include <windows.h>
-#elif defined(HAVE_TERMIOS_H)
-#include <termios.h>
-#include <sys/ioctl.h>
-#include <unistd.h>
-#endif
-#include "debug.h"
-
-/**
- * \addtogroup buffer-utils
- * @{
- */
-size_t
-ansi_length(const char* str, size_t len) {
-  size_t i, n = 0, p;
-  for(i = 0; i < len;) {
-    if(str[i] == 0x1b && (p = ansi_skip(&str[i], len - i)) > 0) {
-      i += p;
-      continue;
-    }
-    n++;
-    i++;
-  }
-  return n;
-}
-
-size_t
-ansi_skip(const char* str, size_t len) {
-  size_t pos = 0;
-  if(str[pos] == 0x1b) {
-    if(++pos < len && str[pos] == '[') {
-      while(++pos < len)
-        if(is_alphanumeric_char(str[pos]))
-          break;
-      if(++pos < len && str[pos] == '~')
-        ++pos;
-      return pos;
-    }
-  }
-  return 0;
-}
-
-size_t
-ansi_truncate(const char* str, size_t len, size_t limit) {
-  size_t i, n = 0, p;
-  for(i = 0; i < len;) {
-    if((p = ansi_skip(&str[i], len - i)) > 0) {
-      i += p;
-      continue;
-    }
-    n += is_escape_char(str[i]) ? 2 : 1;
-
-    i++;
-    if(n > limit)
-      break;
-  }
-  return i;
-}
-
-int64_t
-array_search(void* a, size_t m, size_t elsz, void* needle) {
-  char* ptr = a;
-  int64_t n, ret;
-  n = m / elsz;
-  for(ret = 0; ret < n; ret++) {
-    if(!memcmp(ptr, needle, elsz))
-      return ret;
-
-    ptr += elsz;
-  }
-  return -1;
-}
-
-char*
-str_escape(const char* s) {
-  DynBuf dbuf;
-  dbuf_init2(&dbuf, 0, 0);
-  dbuf_put_escaped(&dbuf, s, strlen(s));
-  dbuf_0(&dbuf);
-  return (char*)dbuf.buf;
-}
-
-char*
-byte_escape(const void* s, size_t n) {
-  DynBuf dbuf;
-  dbuf_init2(&dbuf, 0, 0);
-  dbuf_put_escaped(&dbuf, s, n);
-  dbuf_0(&dbuf);
-  return (char*)dbuf.buf;
-}
-
-size_t
-byte_findb(const void* haystack, size_t hlen, const void* what, size_t wlen) {
-  size_t i, last;
-  const char* s = (const char*)haystack;
-  if(hlen < wlen)
-    return hlen;
-  last = hlen - wlen;
-  for(i = 0; i <= last; i++) {
-    if(byte_equal(s, wlen, what))
-      return i;
-    s++;
-  }
-  return hlen;
-}
-
-size_t
-byte_finds(const void* haystack, size_t hlen, const char* what) {
-  return byte_findb(haystack, hlen, what, strlen(what));
-}
-
-size_t
-byte_equal(const void* s, size_t n, const void* t) {
-  return memcmp(s, t, n) == 0;
-}
-
-void
-byte_copy(void* out, size_t len, const void* in) {
-  char* s = (char*)out;
-  const char* t = (const char*)in;
-  size_t i;
-  for(i = 0; i < len; ++i)
-    s[i] = t[i];
-}
-
-void
-byte_copyr(void* out, size_t len, const void* in) {
-  char* s = (char*)out + len;
-  const char* t = (const char*)in;
-  const char* u = t + len;
-
-  for(;;) {
-    if(t >= u)
-      break;
-    --u;
-    --s;
-    *s = *u;
-  }
-}
-
-size_t
-byte_rchrs(const char* in, size_t len, const char needles[], size_t nn) {
-  const char *s = in, *end = in + len, *found = 0;
-  size_t i;
-  for(; s < end; s++) {
-    for(i = 0; i < nn; ++i) {
-      if(*s == needles[i])
-        found = s;
-    }
-  }
-  return (size_t)((found ? found : s) - in);
-}
-
-char*
-dbuf_at_n(const DynBuf* db, size_t i, size_t* n, char sep) {
-  size_t p, l = 0;
-  for(p = 0; p < db->size; ++p) {
-    if(l == i) {
-      *n = byte_chr((const char*)&db->buf[p], db->size - p, sep);
-      return (char*)&db->buf[p];
-    }
-    if(db->buf[p] == sep)
-      ++l;
-  }
-  *n = 0;
-  return 0;
-}
-
-const char*
-dbuf_last_line(DynBuf* db, size_t* len) {
-  size_t i;
-
-  if((i = byte_rchr(db->buf, db->size, '\n')) < db->size)
-    i++;
-  else
-    i = 0;
-
-  if(len)
-    *len = db->size - i;
-
-  return (const char*)&db->buf[i];
-}
-
-int
-dbuf_prepend(DynBuf* s, const uint8_t* data, size_t len) {
-  int ret;
-  if(!(ret = dbuf_reserve_start(s, len)))
-    memcpy(s->buf, data, len);
-
-  return 0;
-}
-
-void
-dbuf_put_colorstr(DynBuf* db, const char* str, const char* color, int with_color) {
-  if(with_color)
-    dbuf_putstr(db, color);
-
-  dbuf_putstr(db, str);
-  if(with_color)
-    dbuf_putstr(db, COLOR_NONE);
-}
-
-void
-dbuf_put_escaped_pred(DynBuf* db, const char* str, size_t len, int (*pred)(int)) {
-  size_t i = 0, j;
-  char c;
-
-  while(i < len) {
-    if((j = predicate_find(&str[i], len - i, pred))) {
-      dbuf_append(db, (const uint8_t*)&str[i], j);
-      i += j;
-    }
-
-    if(i == len)
-      break;
-
-    dbuf_putc(db, '\\');
-
-    if(str[i] == 0x1b) {
-      dbuf_append(db, (const uint8_t*)"x1b", 3);
-    } else {
-      int r = pred(str[i]);
-
-      dbuf_putc(db, (r > 1 && r <= 127) ? r : (c = escape_char_letter(str[i])) ? c : str[i]);
-
-      if(r == 'u' || r == 'x')
-        dbuf_printf(db, r == 'u' ? "%04x" : "%02x", str[i]);
-    }
-
-    i++;
-  }
-}
-
-const uint8_t escape_url_tab[256] = {
-    '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%',  '%', '%', '%',
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   '%',
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
-    '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%',  '%', '%', '%',
-};
-
-const uint8_t escape_noquote_tab[256] = {
-    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
-    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
-};
-
-const uint8_t escape_singlequote_tab[256] = {
-    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0,    0,    0,    0x27, 0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
-    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
-};
-
-const uint8_t escape_doublequote_tab[256] = {
-    'x', 'x', 'x', 'x', 'x', 'x', 'x',  'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-
-    'x', 'x', 'x', 'x', 0,   0,   0x22, 0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
-    'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
-};
-
-const uint8_t escape_backquote_tab[256] = {
-    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0,   0x76, 0x66, 0,   'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0x24, 0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,   0,    0x60, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
-    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u', 'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
-};
-
-void
-dbuf_put_escaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]) {
-  size_t i = 0, clen;
-  int32_t c;
-  const uint8_t *pos, *end, *next;
-
-  for(pos = (const uint8_t*)str, end = pos + len; pos < end; pos = next) {
-    uint8_t r, ch;
-
-    if((c = unicode_from_utf8(pos, end - pos, &next)) < 0)
-      break;
-    clen = next - pos;
-    ch = c;
-    r = (clen >= 2 || c > 0xff) ? 'u' : table[c];
-
-    if(r == 'u' && clen > 1 && (c & 0xffffff00) == 0) {
-      r = 'x';
-      // ch = c >> 8;
-    }
-
-    if(r == '%') {
-      static const char hexdigits[] = "0123456789ABCDEF";
-
-      dbuf_putc(db, '%');
-      dbuf_putc(db, hexdigits[c >> 4]);
-      dbuf_putc(db, hexdigits[c & 0xf]);
-    } else if(c == 0x1b) {
-      dbuf_putstr(db, "\\x1b");
-    } else if(r == 'u') {
-      dbuf_printf(db, c > 0xffff ? "\\u{%X}" : "\\u%04x", c);
-    } else if(r == 'x') {
-      dbuf_printf(db, "\\x%02x", ch);
-    } else if(r) {
-      dbuf_putc(db, '\\');
-      dbuf_putc(db, (r > 1 && r <= 127) ? r : (c = escape_char_letter(ch)) ? c : ch);
-    } else {
-      dbuf_put(db, pos, next - pos);
-    }
-
-    i++;
-  }
-}
-
-void
-dbuf_put_unescaped_pred(DynBuf* db, const char* str, size_t len, int (*pred)(const char*, size_t*)) {
-  size_t i = 0, j;
-  // char c;
-
-  while(i < len) {
-    int r = 0;
-    if((j = byte_chr(&str[i], len - i, '\\'))) {
-      dbuf_append(db, (const uint8_t*)&str[i], j);
-      i += j;
-    }
-    if(i == len)
-      break;
-    size_t n = 1;
-
-    if(pred) {
-      r = pred(&str[i + 1], &n);
-
-      if(!r && n == 1)
-        dbuf_putc(db, '\\');
-    }
-
-    if(r >= 0)
-      dbuf_putc(db, /*n > 1 ||*/ r ? /*(r > 1 && r < 256) ?*/ r : str[i]);
-    i += n;
-  }
-}
-
-static inline int
-hexdigit(char c) {
-  if(c >= '0' && c <= '9')
-    return c - '0';
-
-  if(c >= 'a' && c <= 'f')
-    c -= 32;
-
-  if(c >= 'A' && c <= 'F')
-    return c - 'A' + 10;
-
-  return -1;
-}
-
-void
-dbuf_put_unescaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]) {
-  size_t i = 0, j;
-  char escape_char = table == escape_url_tab ? '%' : '\\';
-
-  while(i < len) {
-    if((j = byte_chr(&str[i], len - i, escape_char))) {
-      dbuf_append(db, (const uint8_t*)&str[i], j);
-      i += j;
-    }
-
-    if(i == len)
-      break;
-
-    if(escape_char == '%') {
-      int hi = hexdigit(str[i + 1]), lo = hexdigit(str[i + 2]);
-      uint8_t c = (hi << 4) | (lo & 0xf);
-      dbuf_putc(db, c);
-
-      i += 2;
-
-    } else {
-      ++i;
-
-      uint8_t c;
-
-      switch(str[i]) {
-        case 'b': c = '\b'; break;
-        case 't': c = '\t'; break;
-        case 'n': c = '\n'; break;
-        case 'v': c = '\v'; break;
-        case 'f': c = '\f'; break;
-        case 'r': c = '\r'; break;
-        default: c = str[i]; break;
-      }
-
-      uint8_t r = table[c];
-
-      if(!(r && r != 'x' && r != 'u')) {
-        dbuf_putc(db, '\\');
-        dbuf_putc(db, c);
-      } else {
-        dbuf_putc(db, str[i] == r ? c : r);
-      }
-    }
-
-    ++i;
-  }
-}
-
-void
-dbuf_put_escaped(DynBuf* db, const char* str, size_t len) {
-  return dbuf_put_escaped_table(db, str, len, escape_noquote_tab);
-}
-
-void
-dbuf_put_value(DynBuf* db, JSContext* ctx, JSValueConst value) {
-  const char* str;
-  size_t len;
-  str = JS_ToCStringLen(ctx, &len, value);
-  dbuf_append(db, str, len);
-  JS_FreeCString(ctx, str);
-}
-
-void
-dbuf_put_uint32(DynBuf* db, uint32_t num) {
-  char buf[FMT_ULONG];
-  dbuf_put(db, (const uint8_t*)buf, fmt_ulong(buf, num));
-}
-
-void
-dbuf_put_atom(DynBuf* db, JSContext* ctx, JSAtom atom) {
-  const char* str;
-  str = JS_AtomToCString(ctx, atom);
-  dbuf_putstr(db, str);
-  JS_FreeCString(ctx, str);
-}
-
-int
-dbuf_reserve_start(DynBuf* s, size_t len) {
-  if(unlikely((s->size + len) > s->allocated_size)) {
-    if(dbuf_realloc(s, s->size + len))
-      return -1;
-  }
-  if(s->size > 0)
-    memcpy(s->buf + len, s->buf, s->size);
-
-  s->size += len;
-  return 0;
-}
-
-uint8_t*
-dbuf_reserve(DynBuf* s, size_t len) {
-  if(unlikely((s->size + len) > s->allocated_size))
-    if(dbuf_realloc(s, s->size + len))
-      return 0;
-
-  return &s->buf[s->size];
-}
-
-size_t
-dbuf_token_pop(DynBuf* db, char delim) {
-  size_t n, p, len;
-  len = db->size;
-  for(n = db->size; n > 0;) {
-    if((p = byte_rchr(db->buf, n, delim)) == n) {
-      db->size = 0;
-      break;
-    }
-    if(p > 0 && db->buf[p - 1] == '\\') {
-      n = p - 1;
-      continue;
-    }
-    db->size = p;
-    break;
-  }
-  return len - db->size;
-}
-
-size_t
-dbuf_token_push(DynBuf* db, const char* str, size_t len, char delim) {
-  size_t pos;
-  if(db->size)
-    dbuf_putc(db, delim);
-
-  pos = db->size;
-  dbuf_put_escaped_pred(db, str, len, is_dot_char);
-  return db->size - pos;
-}
-
-JSValue
-dbuf_tostring_free(DynBuf* s, JSContext* ctx) {
-  JSValue r;
-  r = JS_NewStringLen(ctx, s->buf ? (const char*)s->buf : "", s->buf ? s->size : 0);
-  dbuf_free(s);
-  return r;
-}
-
-ssize_t
-dbuf_load(DynBuf* s, const char* filename) {
-  FILE* fp;
-  size_t nbytes = 0;
-  if((fp = fopen(filename, "rb"))) {
-    char buf[4096];
-    size_t r;
-    while(!feof(fp)) {
-      if((r = fread(buf, 1, sizeof(buf), fp)) == 0) {
-        fclose(fp);
-        return -1;
-      }
-      dbuf_put(s, (uint8_t const*)buf, r);
-      nbytes += r;
-    }
-    fclose(fp);
-  }
-  return nbytes;
-}
-
-int
-dbuf_vprintf(DynBuf* s, const char* fmt, va_list ap) {
-
-  s->size += vsnprintf((char*)(s->buf + s->size), s->allocated_size - s->size, fmt, ap);
-
-  return 0;
-}
-
-InputBuffer
-js_input_buffer(JSContext* ctx, JSValueConst value) {
-  InputBuffer ret = {{{0, 0}}, 0, &input_buffer_free_default, JS_UNDEFINED, {0, INT64_MAX}};
-
-  if(js_is_typedarray(ctx, value)) {
-    ret.value = offset_typedarray(&ret.range, value, ctx);
-  } else if(js_is_arraybuffer(ctx, value) || js_is_sharedarraybuffer(ctx, value)) {
-    ret.value = JS_DupValue(ctx, value);
-  }
-
-  if(js_is_arraybuffer(ctx, ret.value) || js_is_sharedarraybuffer(ctx, ret.value)) {
-    block_arraybuffer(&ret.block, ret.value, ctx);
-  } else {
-    JS_ThrowTypeError(ctx, "Invalid type (%s) for input buffer", js_value_typestr(ctx, ret.value));
-    JS_FreeValue(ctx, ret.value);
-    ret.value = JS_EXCEPTION;
-  }
-
-  return ret;
-}
-
-#undef free
-
-InputBuffer
-js_input_chars(JSContext* ctx, JSValueConst value) {
-  InputBuffer ret = {{{0, 0}}, 0, &input_buffer_free_default, JS_UNDEFINED, OFFSET_INIT()};
-
-  if(JS_IsString(value)) {
-    ret.data = (uint8_t*)JS_ToCStringLen(ctx, &ret.size, value);
-    ret.value = JS_DupValue(ctx, value);
-    ret.free = &input_buffer_free_default;
-  } else {
-    ret = js_input_buffer(ctx, value);
-  }
-
-  return ret;
-}
-
-InputBuffer
-js_input_args(JSContext* ctx, int argc, JSValueConst argv[]) {
-  InputBuffer input = js_input_chars(ctx, argv[0]);
-
-  if(argc > 1)
-    js_offset_length(ctx, input.size, argc - 1, argv + 1, &input.range);
-
-  return input;
-}
-
-InputBuffer
-js_output_args(JSContext* ctx, int argc, JSValueConst argv[]) {
-  InputBuffer output = js_input_buffer(ctx, argv[0]);
-
-  if(argc > 1)
-    js_offset_length(ctx, output.size, argc - 1, argv + 1, &output.range);
-
-  return output;
-}
-
-BOOL
-input_buffer_valid(const InputBuffer* in) {
-  return !JS_IsException(in->value);
-}
-
-InputBuffer
-input_buffer_clone(const InputBuffer* in, JSContext* ctx) {
-  InputBuffer ret = js_input_buffer(ctx, in->value);
-
-  ret.pos = in->pos;
-  ret.size = in->size;
-  ret.free = in->free;
-
-  return ret;
-}
-
-void
-input_buffer_dump(const InputBuffer* in, DynBuf* db) {
-  dbuf_printf(db, "(InputBuffer){ .data = %p, .size = %lu, .pos = %lu, .free = %p }", in->data, (unsigned long)in->size, (unsigned long)in->pos, in->free);
-}
-
-void
-input_buffer_free(InputBuffer* in, JSContext* ctx) {
-  if(in->data) {
-    in->free(ctx, (const char*)in->data, in->value);
-    in->data = 0;
-    in->size = 0;
-    in->pos = 0;
-    in->value = JS_UNDEFINED;
-  }
-}
-
-const uint8_t*
-input_buffer_peek(InputBuffer* in, size_t* lenp) {
-  input_buffer_peekc(in, lenp);
-  return input_buffer_data(in) + in->pos;
-}
-
-const uint8_t*
-input_buffer_get(InputBuffer* in, size_t* lenp) {
-  const uint8_t* ret = input_buffer_peek(in, lenp);
-
-  in->pos += *lenp;
-
-  return ret;
-}
-
-const char*
-input_buffer_currentline(InputBuffer* in, size_t* len) {
-  size_t i;
-
-  if((i = byte_rchr(input_buffer_data(in), in->pos, '\n')) < in->pos)
-    i++;
-
-  if(len)
-    *len = in->pos - i;
-
-  return (const char*)&input_buffer_data(in)[i];
-}
-
-size_t
-input_buffer_column(InputBuffer* in, size_t* len) {
-  size_t i;
-
-  if((i = byte_rchr(input_buffer_data(in), in->pos, '\n')) < in->pos)
-    i++;
-
-  return in->pos - i;
-}
-
-int
-js_offset_length(JSContext* ctx, int64_t size, int argc, JSValueConst argv[], OffsetLength* off_len_p) {
-  int ret = 0;
-  int64_t off = 0, len = size;
-
-  if(argc >= 1 && JS_IsNumber(argv[0])) {
-    if(!JS_ToInt64(ctx, &off, argv[0]))
-      ret = 1;
-
-    if(argc >= 2 && JS_IsNumber(argv[1]))
-      if(!JS_ToInt64(ctx, &len, argv[1]))
-        ret = 2;
-
-    if(size && off != size)
-      off = ((off % size) + size) % size;
-
-    if(len >= 0)
-      len = MIN_NUM(len, size - off);
-    else
-      len = size - off;
-
-    if(off_len_p) {
-      off_len_p->offset = off;
-      off_len_p->length = len;
-    }
-  }
-
-  return ret;
-}
-
-int
-js_index_range(JSContext* ctx, int64_t size, int argc, JSValueConst argv[], IndexRange* idx_rng_p) {
-  int ret = 0;
-  int64_t start = 0, end = size;
-
-  if(argc >= 1 && JS_IsNumber(argv[0])) {
-    if(!JS_ToInt64(ctx, &start, argv[0]))
-      ret = 1;
-
-    if(argc >= 2 && JS_IsNumber(argv[1]))
-      if(!JS_ToInt64(ctx, &end, argv[1]))
-        ret = 2;
-
-    if(size > 0) {
-      start = ((start % size) + size) % size;
-      end = ((end % size) + size) % size;
-    }
-
-    if(end > size)
-      end = size;
-
-    if(idx_rng_p) {
-      idx_rng_p->start = start;
-      idx_rng_p->end = end;
-    }
-  }
-
-  return ret;
-}
-
-int
-screen_size(int size[2]) {
-#ifdef _WIN32
-  CONSOLE_SCREEN_BUFFER_INFO csbi;
-
-  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
-  size[0] = csbi.srWindow.Right - csbi.srWindow.Left + 1;
-  size[1] = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
-  return 0;
-
-#elif defined(HAVE_TERMIOS_H)
-  {
-    struct winsize w = {.ws_col = -1, .ws_row = -1};
-
-    if(isatty(STDIN_FILENO))
-      ioctl(STDIN_FILENO, TIOCGWINSZ, &w);
-    else if(isatty(STDOUT_FILENO))
-      ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
-    else if(isatty(STDERR_FILENO))
-      ioctl(STDERR_FILENO, TIOCGWINSZ, &w);
-
-    size[0] = w.ws_col;
-    size[1] = w.ws_row;
-    return 0;
-  }
-#else
-  size[0] = 80;
-  size[1] = 25;
-  return 0;
-#endif
-  return -1;
-}
-
-#undef js_realloc_rt
-void
-js_dbuf_allocator(JSContext* ctx, DynBuf* s) {
-  dbuf_init2(s, JS_GetRuntime(ctx), (DynBufReallocFunc*)js_realloc_rt);
-}
-
-inline int
-input_buffer_peekc(InputBuffer* in, size_t* lenp) {
-  const uint8_t *pos, *end, *next;
-  int cp;
-  pos = input_buffer_data(in) + in->pos;
-  end = input_buffer_data(in) + input_buffer_length(in);
-  cp = unicode_from_utf8(pos, end - pos, &next);
-
-  *lenp = next - pos;
-
-  return cp;
-}
-
-inline int
-input_buffer_putc(InputBuffer* in, unsigned int c, JSContext* ctx) {
-  int len;
-
-  if(in->pos + UTF8_CHAR_LEN_MAX > in->size)
-    if(block_realloc(&in->block, in->pos + UTF8_CHAR_LEN_MAX, ctx))
-      return -1;
-
-  len = unicode_to_utf8(&in->data[in->pos], c);
-
-  in->pos += len;
-
-  return len;
-}
-
-size_t
-dbuf_bitflags(DynBuf* db, uint32_t bits, const char* const names[]) {
-  size_t i, n = 0;
-  for(i = 0; i < sizeof(bits) * 8; i++) {
-    if(bits & (1 << i)) {
-      size_t len = strlen(names[i]);
-      if(n) {
-        n++;
-        dbuf_putstr(db, "|");
-      }
-      dbuf_append(db, names[i], len);
-      n += len;
-    }
-  }
-  return n;
-}
-
-/**
- * @}
- */

src/quickjs/buffer-utils.h

@@ -1,348 +0,0 @@
-#ifndef BUFFER_UTILS_H
-#define BUFFER_UTILS_H
-
-#include <quickjs.h>
-#include <cutils.h>
-#include <stdarg.h>
-
-#include "char-utils.h"
-
-/**
- * \defgroup buffer-utils buffer-utils: Buffer Utilities
- * @{
- */
-int64_t array_search(void* a, size_t m, size_t elsz, void* needle);
-#define array_contains(a, m, elsz, needle) (array_search((a), (m), (elsz), (needle)) != -1)
-
-size_t ansi_length(const char*, size_t);
-size_t ansi_skip(const char*, size_t);
-size_t ansi_truncate(const char*, size_t, size_t limit);
-int64_t array_search(void*, size_t, size_t elsz, void* needle);
-char* str_escape(const char*);
-
-char* byte_escape(const void*, size_t);
-size_t byte_findb(const void*, size_t, const void* what, size_t wlen);
-size_t byte_finds(const void*, size_t, const char* what);
-size_t byte_equal(const void* s, size_t n, const void* t);
-void byte_copy(void* out, size_t len, const void* in);
-void byte_copyr(void* out, size_t len, const void* in);
-size_t byte_rchrs(const char* in, size_t len, const char needles[], size_t nn);
-
-#define DBUF_INIT_0() \
-  (DynBuf) { 0, 0, 0, 0, 0, 0 }
-#define DBUF_INIT_CTX(ctx) \
-  (DynBuf) { 0, 0, 0, 0, (DynBufReallocFunc*)js_realloc_rt, JS_GetRuntime(ctx) }
-
-extern const uint8_t escape_url_tab[256], escape_noquote_tab[256], escape_singlequote_tab[256], escape_doublequote_tab[256], escape_backquote_tab[256];
-
-char* dbuf_at_n(const DynBuf*, size_t, size_t* n, char sep);
-const char* dbuf_last_line(DynBuf*, size_t*);
-int dbuf_prepend(DynBuf*, const uint8_t*, size_t len);
-void dbuf_put_colorstr(DynBuf*, const char*, const char* color, int with_color);
-void dbuf_put_escaped_pred(DynBuf*, const char*, size_t len, int (*pred)(int));
-void dbuf_put_escaped_table(DynBuf*, const char*, size_t len, const uint8_t table[256]);
-void dbuf_put_unescaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]);
-void dbuf_put_unescaped_pred(DynBuf*, const char*, size_t len, int (*pred)());
-void dbuf_put_escaped(DynBuf*, const char*, size_t len);
-void dbuf_put_value(DynBuf*, JSContext*, JSValue value);
-void dbuf_put_uint32(DynBuf* db, uint32_t num);
-void dbuf_put_atom(DynBuf* db, JSContext* ctx, JSAtom atom);
-int dbuf_reserve_start(DynBuf*, size_t);
-uint8_t* dbuf_reserve(DynBuf*, size_t);
-size_t dbuf_token_pop(DynBuf*, char);
-size_t dbuf_token_push(DynBuf*, const char*, size_t len, char delim);
-JSValue dbuf_tostring_free(DynBuf*, JSContext*);
-ssize_t dbuf_load(DynBuf*, const char*);
-int dbuf_vprintf(DynBuf*, const char*, va_list);
-
-int screen_size(int size[2]);
-
-static inline int
-dbuf_putm(DynBuf* db, ...) {
-  int r = 0;
-  va_list a;
-  const char* s;
-  va_start(a, db);
-  while((s = va_arg(a, char*)))
-    if(dbuf_putstr(db, s))
-      return -1;
-  va_end(a);
-  return r;
-}
-
-#define dbuf_append(d, x, n) dbuf_put((d), (const uint8_t*)(x), (n))
-
-static inline size_t
-dbuf_count(DynBuf* db, int ch) {
-  return byte_count(db->buf, db->size, ch);
-}
-
-static inline void
-dbuf_0(DynBuf* db) {
-  dbuf_putc(db, '\0');
-  db->size--;
-}
-
-static inline void
-dbuf_zero(DynBuf* db) {
-  dbuf_realloc(db, 0);
-  db->size = 0;
-}
-
-size_t dbuf_bitflags(DynBuf* db, uint32_t bits, const char* const names[]);
-
-#define js_dbuf_init(ctx, buf) dbuf_init2((buf), (ctx), (realloc_func*)&utils_js_realloc)
-#define js_dbuf_init_rt(rt, buf) dbuf_init2((buf), (rt), (realloc_func*)&utils_js_realloc_rt)
-
-void js_dbuf_allocator(JSContext* ctx, DynBuf* s);
-
-typedef struct {
-  uint8_t* base;
-  size_t size;
-} MemoryBlock;
-
-static inline void
-block_init(MemoryBlock* mb) {
-  mb->base = 0;
-  mb->size = 0;
-}
-
-/* clang-format off */
-static inline void* block_data(const MemoryBlock* mb) { return mb->base; }
-static inline size_t block_length(const MemoryBlock* mb) { return mb->size; }
-static inline void* block_begin(const MemoryBlock* mb) { return mb->base; }
-static inline void* block_end(const MemoryBlock* mb) { return mb->base + mb->size; }
-/* clang-format on */
-
-static inline BOOL
-block_arraybuffer(MemoryBlock* mb, JSValueConst ab, JSContext* ctx) {
-  mb->base = JS_GetArrayBuffer(ctx, &mb->size, ab);
-  return mb->base != 0;
-}
-
-typedef struct {
-  uint8_t *start, *end;
-} PointerRange;
-
-static inline void
-range_init(PointerRange* pr) {
-  pr->end = pr->start = 0;
-}
-
-static inline PointerRange
-range_from(const MemoryBlock* mb) {
-  return (PointerRange){mb->base, mb->base + mb->size};
-}
-
-typedef struct {
-  int64_t start, end;
-} IndexRange;
-
-typedef struct {
-  int64_t offset, length;
-} OffsetLength;
-
-#define OFFSET_INIT() \
-  (OffsetLength) { 0, INT64_MAX }
-
-static inline void
-offset_init(OffsetLength* ol) {
-  ol->offset = 0;
-  ol->length = INT64_MAX;
-}
-
-static inline BOOL
-offset_is_default(const OffsetLength* ol) {
-  return ol->offset == 0 && ol->length == INT64_MAX;
-}
-
-static inline void*
-offset_data(const OffsetLength* ol, const void* x) {
-  return (uint8_t*)x + ol->offset;
-}
-
-static inline size_t
-offset_size(const OffsetLength* ol, size_t n) {
-  if(ol->length == -1)
-    return (signed long)n - ol->offset;
-  return MIN_NUM(ol->length, (signed long)n - ol->offset);
-}
-
-static inline MemoryBlock
-offset_block(const OffsetLength* ol, const void* x, size_t n) {
-  return (MemoryBlock){offset_data(ol, x), offset_size(ol, n)};
-}
-
-static inline PointerRange
-offset_range(const OffsetLength* ol, const void* x, size_t n) {
-  MemoryBlock mb = offset_block(ol, x, n);
-  return range_from(&mb);
-}
-
-static inline OffsetLength
-offset_slice(const OffsetLength ol, int64_t start, int64_t end) {
-  if(start < 0)
-    start = ol.length + (start % ol.length);
-  else if(start > ol.length)
-    start = ol.length;
-  if(end < 0)
-    end = ol.length + (end % ol.length);
-  else if(end > ol.length)
-    end = ol.length;
-
-  return (OffsetLength){start, end - start};
-}
-
-static inline OffsetLength
-offset_offset(const OffsetLength* ol, const OffsetLength* by) {
-  OffsetLength ret;
-  ret.offset = ol->offset + by->offset;
-  ret.length = MIN_NUM(by->length, ol->length - by->offset);
-  return ret;
-}
-
-static inline OffsetLength
-offset_from_indexrange(const IndexRange* ir) {
-  OffsetLength ret;
-  ret.offset = ir->start;
-  ret.length = ir->end - ir->start;
-  return ret;
-}
-
-static inline JSValue
-offset_typedarray(OffsetLength* ol, JSValueConst array, JSContext* ctx) {
-  JSValue ret;
-  size_t offset, length;
-
-  ret = JS_GetTypedArrayBuffer(ctx, array, &offset, &length, NULL);
-
-  if(!JS_IsException(ret)) {
-    ol->offset = offset;
-    ol->length = length;
-  }
-
-  return ret;
-}
-
-static inline IndexRange
-indexrange_from_offset(const OffsetLength* ol) {
-  IndexRange ret;
-  ret.start = ol->offset;
-  ret.end = ol->offset + ol->length;
-  return ret;
-}
-
-static inline MemoryBlock
-block_range(const MemoryBlock* mb, const OffsetLength* range) {
-  MemoryBlock ret;
-  ret.base = mb->base + range->offset;
-  ret.size = MIN_NUM((size_t)range->length, mb->size - range->offset);
-  return ret;
-}
-
-static inline int
-block_realloc(MemoryBlock* mb, size_t new_size, JSContext* ctx) {
-  if((mb->base = js_realloc(ctx, mb->base, new_size))) {
-    mb->size = new_size;
-    return 0;
-  }
-  return -1;
-}
-
-typedef struct InputBuffer {
-  union {
-    MemoryBlock block;
-    struct {
-      uint8_t* data;
-      size_t size;
-    };
-  };
-  size_t pos;
-  void (*free)(JSContext*, const char*, JSValue);
-  JSValue value;
-  OffsetLength range;
-} InputBuffer;
-
-static inline void
-input_buffer_free_default(JSContext* ctx, const char* str, JSValue val) {
-  if(JS_IsString(val))
-    JS_FreeCString(ctx, str);
-
-  if(!JS_IsUndefined(val))
-    JS_FreeValue(ctx, val);
-}
-
-InputBuffer js_input_buffer(JSContext* ctx, JSValueConst value);
-InputBuffer js_input_chars(JSContext* ctx, JSValueConst value);
-InputBuffer js_input_args(JSContext* ctx, int argc, JSValueConst argv[]);
-InputBuffer js_output_args(JSContext* ctx, int argc, JSValueConst argv[]);
-
-InputBuffer input_buffer_clone(const InputBuffer* in, JSContext* ctx);
-BOOL input_buffer_valid(const InputBuffer* in);
-void input_buffer_dump(const InputBuffer* in, DynBuf* db);
-void input_buffer_free(InputBuffer* in, JSContext* ctx);
-
-static inline uint8_t*
-input_buffer_data(const InputBuffer* in) {
-  return offset_data(&in->range, in->data);
-}
-
-static inline size_t
-input_buffer_length(const InputBuffer* in) {
-  return offset_size(&in->range, in->size);
-}
-
-static inline MemoryBlock
-input_buffer_block(InputBuffer* in) {
-  return (MemoryBlock){input_buffer_data(in), input_buffer_length(in)};
-}
-
-static inline MemoryBlock*
-input_buffer_blockptr(InputBuffer* in) {
-  return &in->block;
-}
-
-const uint8_t* input_buffer_get(InputBuffer* in, size_t* lenp);
-const uint8_t* input_buffer_peek(InputBuffer* in, size_t* lenp);
-const char* input_buffer_currentline(InputBuffer*, size_t* len);
-size_t input_buffer_column(InputBuffer*, size_t* len);
-
-int input_buffer_peekc(InputBuffer* in, size_t* lenp);
-int input_buffer_putc(InputBuffer*, unsigned int, JSContext*);
-
-static inline int
-input_buffer_getc(InputBuffer* in) {
-  size_t n;
-  int ret;
-  ret = input_buffer_peekc(in, &n);
-  in->pos += n;
-  return ret;
-}
-
-static inline void*
-input_buffer_begin(const InputBuffer* in) {
-  return input_buffer_data(in);
-}
-
-static inline void*
-input_buffer_end(const InputBuffer* in) {
-  return input_buffer_data(in) + input_buffer_length(in);
-}
-
-static inline BOOL
-input_buffer_eof(const InputBuffer* in) {
-  return in->pos == input_buffer_length(in);
-}
-
-static inline size_t
-input_buffer_remain(const InputBuffer* in) {
-  return input_buffer_length(in) - in->pos;
-}
-
-int js_offset_length(JSContext*, int64_t size, int argc, JSValueConst argv[], OffsetLength* off_len_p);
-int js_index_range(JSContext*, int64_t size, int argc, JSValueConst argv[], IndexRange* idx_rng_p);
-
-/**
- * @}
- */
-#endif /* defined(BUFFER_UTILS) */

src/quickjs/char-utils.c

@@ -1,578 +0,0 @@
-#include "char-utils.h"
-#include "libutf.h"
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
-#include <winnls.h>
-#include <windows.h>
-#include <wchar.h>
-#endif
-
-/**
- * \addtogroup char-utils
- * @{
- */
-size_t
-token_length(const char* str, size_t len, char delim) {
-  const char *s, *e;
-  size_t pos;
-
-  for(s = str, e = s + len; s < e; s += pos + 1) {
-    pos = byte_chr(s, e - s, delim);
-
-    if(s + pos == e)
-      break;
-
-    if(pos == 0 || s[pos - 1] != '\\') {
-      s += pos;
-      break;
-    }
-  }
-
-  return s - str;
-}
-
-size_t
-fmt_ulong(char* dest, uint32_t i) {
-  uint32_t len, tmp, len2;
-
-  for(len = 1, tmp = i; tmp > 9; ++len)
-    tmp /= 10;
-
-  if(dest)
-    for(tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10)
-      *--dest = (char)((tmp % 10) + '0');
-
-  return len;
-}
-
-size_t
-fmt_longlong(char* dest, int64_t i) {
-  if(i < 0) {
-    if(dest)
-      *dest++ = '-';
-    return fmt_ulonglong(dest, (uint64_t)-i) + 1;
-  }
-
-  return fmt_ulonglong(dest, (uint64_t)i);
-}
-
-size_t
-fmt_ulonglong(char* dest, uint64_t i) {
-  size_t len;
-  uint64_t tmp, len2;
-
-  for(len = 1, tmp = i; tmp > 9ll; ++len)
-    tmp /= 10ll;
-
-  if(dest)
-    for(tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10ll)
-      *--dest = (tmp % 10ll) + '0';
-
-  return len;
-}
-
-#define tohex(c) (char)((c) >= 10 ? (c)-10 + 'a' : (c) + '0')
-
-size_t
-fmt_xlonglong(char* dest, uint64_t i) {
-  uint64_t len, tmp;
-
-  for(len = 1, tmp = i; tmp > 15ll; ++len)
-    tmp >>= 4ll;
-
-  if(dest)
-    for(tmp = i, dest += len;;) {
-      *--dest = tohex(tmp & 15ll);
-
-      if(!(tmp >>= 4ll))
-        break;
-    }
-
-  return len;
-}
-
-size_t
-fmt_xlonglong0(char* dest, uint64_t num, size_t n) {
-  size_t i = 0, len;
-
-  if((len = fmt_xlonglong(NULL, num)) < n) {
-    len = n - len;
-
-    while(i < len)
-      dest[i++] = '0';
-  }
-
-  i += fmt_xlonglong(&dest[i], num);
-  return i;
-}
-
-size_t
-fmt_8long(char* dest, uint32_t i) {
-  uint32_t len, tmp;
-
-  /* first count the number of bytes needed */
-  for(len = 1, tmp = i; tmp > 7; ++len)
-    tmp >>= 3;
-
-  if(dest)
-    for(tmp = i, dest += len;;) {
-      *--dest = (char)((tmp & 7) + '0');
-
-      if(!(tmp >>= 3))
-        break;
-    }
-
-  return len;
-}
-
-#define tohex(c) (char)((c) >= 10 ? (c)-10 + 'a' : (c) + '0')
-
-size_t
-fmt_xlong(char* dest, uint32_t i) {
-  uint32_t len, tmp;
-
-  /* first count the number of bytes needed */
-  for(len = 1, tmp = i; tmp > 15; ++len)
-    tmp >>= 4;
-
-  if(dest)
-    for(tmp = i, dest += len;;) {
-      *--dest = tohex(tmp & 15);
-
-      if(!(tmp >>= 4))
-        break;
-    }
-
-  return len;
-}
-
-size_t
-fmt_xlong0(char* dest, uint32_t num, size_t n) {
-  size_t i = 0, len;
-
-  if((len = fmt_xlong(NULL, num)) < n) {
-    len = n - len;
-
-    while(i < len)
-      dest[i++] = '0';
-  }
-
-  i += fmt_xlong(&dest[i], num);
-  return i;
-}
-
-size_t
-scan_ushort(const char* src, uint16_t* dest) {
-  const char* cur;
-  uint16_t l;
-
-  for(cur = src, l = 0; *cur >= '0' && *cur <= '9'; ++cur) {
-    uint32_t tmp = l * 10ul + *cur - '0';
-
-    if((uint16_t)tmp != tmp)
-      break;
-
-    l = tmp;
-  }
-
-  if(cur > src)
-    *dest = l;
-
-  return (size_t)(cur - src);
-}
-
-size_t
-scan_uint(const char* src, uint32_t* dest) {
-  uint64_t u64;
-  size_t r = scan_ulonglong(src, &u64);
-  *dest = u64;
-  return r;
-}
-
-size_t
-scan_int(const char* src, int32_t* dest) {
-  int64_t i64;
-  size_t r = scan_longlong(src, &i64);
-  *dest = i64;
-  return r;
-}
-
-#ifndef MAXLONG
-#define MAXLONG (((uint32_t)-1) >> 1)
-#endif
-
-size_t
-scan_longlong(const char* src, int64_t* dest) {
-  size_t i, o;
-  uint64_t l;
-  char c = src[0];
-  unsigned int neg = c == '-';
-  o = c == '-' || c == '+';
-
-  if((i = scan_ulonglong(src + o, &l))) {
-    if(i > 0ll && l > MAXLONG + neg) {
-      l /= 10ll;
-      --i;
-    }
-
-    if(i + o)
-      *dest = (int64_t)(c == '-' ? -l : l);
-
-    return i + o;
-  }
-
-  return 0;
-}
-
-size_t
-scan_ulonglong(const char* src, uint64_t* dest) {
-  const char* tmp = src;
-  uint64_t l = 0;
-  unsigned char c;
-
-  while((c = (unsigned char)(*tmp - '0')) < 10) {
-    uint64_t n;
-    n = l << 3ll;
-
-    if((n >> 3ll) != l)
-      break;
-
-    if(n + (l << 1ll) < n)
-      break;
-
-    n += l << 1ll;
-
-    if(n + c < n)
-      break;
-
-    l = n + c;
-    ++tmp;
-  }
-
-  if(tmp - src)
-    *dest = l;
-
-  return (size_t)(tmp - src);
-}
-
-size_t
-scan_xlonglong(const char* src, uint64_t* dest) {
-  const char* tmp = src;
-  int64_t l = 0;
-  unsigned char c;
-
-  while((c = scan_fromhex(*tmp)) < 16) {
-    l = (l << 4) + c;
-    ++tmp;
-  }
-
-  *dest = l;
-  return tmp - src;
-}
-
-size_t
-scan_8longn(const char* src, size_t n, uint32_t* dest) {
-  const char* tmp = src;
-  uint32_t l = 0;
-  unsigned char c;
-
-  while(n-- > 0 && (c = (unsigned char)(*tmp - '0')) < 8) {
-    if(l >> (sizeof(l) * 8 - 3))
-      break;
-
-    l = l * 8 + c;
-    ++tmp;
-  }
-
-  *dest = l;
-  return (size_t)(tmp - src);
-}
-
-size_t
-scan_whitenskip(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = t + limit; t < u; ++t)
-    if(!is_whitespace_char(*t))
-      break;
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_nonwhitenskip(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = t + limit; t < u; ++t)
-    if(is_whitespace_char(*t))
-      break;
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_line(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = s + limit; t < u; ++t)
-    if(*t == '\n' || *t == '\r')
-      break;
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_lineskip(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = s + limit; t < u; ++t)
-    if(*t == '\n') {
-      ++t;
-      break;
-    }
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_lineskip_escaped(const char* s, size_t limit) {
-  const char *t, *u;
-
-  for(t = s, u = s + limit; t < u; ++t) {
-    if(*t == '\\') {
-      ++t;
-      continue;
-    }
-    if(*t == '\n') {
-      ++t;
-      break;
-    }
-  }
-
-  return (size_t)(t - s);
-}
-
-size_t
-scan_eolskip(const char* s, size_t limit) {
-  size_t n = 0;
-
-  if(n + 1 < limit && s[0] == '\r' && s[1] == '\n')
-    n += 2;
-  else if(n < limit && s[0] == '\n')
-    n += 1;
-
-  return n;
-}
-
-size_t
-utf8_strlen(const void* in, size_t len) {
-  const uint8_t *pos, *end, *next;
-  size_t i = 0;
-
-  for(pos = (const uint8_t*)in, end = pos + len; pos < end; pos = next, ++i)
-    unicode_from_utf8(pos, end - pos, &next);
-
-  return i;
-}
-
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
-wchar_t*
-utf8_towcs(const char* s) {
-  int len = (int)strlen(s);
-  int n = MultiByteToWideChar(CP_UTF8, 0, s, len, NULL, 0);
-  wchar_t* ret;
-
-  if((ret = (wchar_t*)malloc((n + 1) * sizeof(wchar_t)))) {
-    MultiByteToWideChar(CP_UTF8, 0, s, len, ret, n);
-    ret[n] = L'\0';
-  }
-
-  return ret;
-}
-
-char*
-utf8_fromwcs(const wchar_t* wstr) {
-  int len = (int)wcslen(wstr);
-  int n = WideCharToMultiByte(CP_UTF8, 0, wstr, len, NULL, 0, NULL, NULL);
-  char* ret;
-
-  if((ret = malloc((n + 1)))) {
-    WideCharToMultiByte(CP_UTF8, 0, wstr, len, ret, n, NULL, NULL);
-    ret[n] = '\0';
-  }
-
-  return ret;
-}
-#endif
-
-BOOL
-utf16_multiword(const void* in) {
-  const uint16_t* p16 = in;
-  LibutfC16Type type = libutf_c16_type(p16[0]);
-
-  return !((LIBUTF_UTF16_NOT_SURROGATE == type) || (LIBUTF_UTF16_SURROGATE_HIGH != type || LIBUTF_UTF16_SURROGATE_LOW != libutf_c16_type(p16[1])));
-}
-
-int
-case_lowerc(int c) {
-  if(c >= 'A' && c <= 'Z')
-    c += 'a' - 'A';
-
-  return c;
-}
-
-int
-case_starts(const char* a, const char* b) {
-  const char *s, *t;
-
-  for(s = a, t = b;; ++s, ++t) {
-    unsigned char x, y;
-
-    if(!*t)
-      return 1;
-
-    x = case_lowerc(*s);
-    y = case_lowerc(*t);
-
-    if(x != y)
-      break;
-
-    if(!x)
-      break;
-  }
-
-  return 0;
-}
-
-int
-case_diffb(const void* S, size_t len, const void* T) {
-  unsigned char x, y;
-  const char *s, *t;
-
-  for(s = (const char*)S, t = (const char*)T; len > 0;) {
-    --len;
-    x = case_lowerc(*s);
-    y = case_lowerc(*t);
-
-    ++s;
-    ++t;
-
-    if(x != y)
-      return ((int)(unsigned int)x) - ((int)(unsigned int)y);
-  }
-
-  return 0;
-}
-
-size_t
-case_findb(const void* haystack, size_t hlen, const void* what, size_t wlen) {
-  size_t i, last;
-  const char* s = haystack;
-
-  if(hlen < wlen)
-    return hlen;
-
-  last = hlen - wlen;
-
-  for(i = 0; i <= last; i++, s++)
-    if(!case_diffb(s, wlen, what))
-      return i;
-
-  return hlen;
-}
-
-size_t
-case_finds(const void* haystack, const char* what) {
-  return case_findb(haystack, strlen(haystack), what, strlen(what));
-}
-
-ssize_t
-write_file(const char* file, const void* buf, size_t len) {
-  FILE* f;
-  ssize_t ret = -1;
-
-  if((f = fopen(file, "w+")))
-    switch(fwrite(buf, len, 1, f)) {
-      case 1: {
-        ret = len;
-        break;
-      }
-    }
-
-  fflush(f);
-  ret = ftell(f);
-  fclose(f);
-
-  return ret;
-}
-
-ssize_t
-puts_file(const char* file, const char* s) {
-  return write_file(file, s, strlen(s));
-}
-
-size_t
-u64toa(char* x, uint64_t num, int base) {
-  size_t len = 0;
-  uint64_t n = num;
-
-  do {
-    n /= base;
-    len++;
-    x++;
-  } while(n != 0);
-
-  *x-- = '\0';
-
-  do {
-    char c = num % base;
-    num /= base;
-
-    if(c >= 10)
-      c += 'a' - '0' - 10;
-    *x-- = c + '0';
-  } while(num != 0);
-
-  return len;
-}
-
-size_t
-i64toa(char* x, int64_t num, int base) {
-  size_t pos = 0, len;
-
-  if(num < 0) {
-    x[pos++] = '-';
-    num = -num;
-  }
-
-  len = u64toa(&x[pos], num, base);
-
-  return pos + len;
-}
-
-size_t
-str_findb(const char* s1, const char* x, size_t n) {
-  const char* b;
-  size_t i, j, len = strlen(s1);
-
-  if(len >= n) {
-    size_t end = len - n + 1;
-
-    for(i = 0; i < end; i++) {
-      b = &s1[i];
-
-      for(j = 0; x[j] == b[j];)
-        if(++j == n)
-          return i;
-    }
-  }
-
-  return len;
-}
-
-size_t
-str_find(const void* s, const void* what) {
-  return str_findb(s, what, strlen(what));
-}
-/**
- * @}
- */

src/quickjs/char-utils.h

@@ -1,441 +0,0 @@
-#ifndef CHAR_UTILS_H
-#define CHAR_UTILS_H
-
-#include <cutils.h>
-#include <string.h>
-#include "debug.h"
-
-/**
- * \defgroup char-utils char-utils: Character Utilities
- * @{
- */
-#define is_control_char(c) ((c) == '\a' || (c) == '\b' || (c) == '\t' || (c) == '\n' || (c) == '\v' || (c) == '\f' || (c) == '\r')
-#define is_alphanumeric_char(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
-
-#define is_digit_char(c) ((c) >= '0' && (c) <= '9')
-#define is_print_char(c) ((c) >= ' ' && (c) <= '\x7f')
-#define is_newline_char(c) ((c) == '\n')
-#define is_identifier_char(c) (is_alphanumeric_char(c) || is_digit_char(c) || (c) == '$' || (c) == '_')
-#define is_whitespace_char(c) ((c) == ' ' || (c) == '\t' || (c) == '\v' || (c) == '\n' || (c) == '\r')
-
-#define str_equal(s, t) (!strcmp((s), (t)))
-
-static inline int
-escape_char_pred(int c) {
-  static const unsigned char table[256] = {
-      'x', 'x', 'x', 'x', 'x', 'x',  'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
-      'x', 'x', 'x', 0,   0,   0,    0,   0,   0,    0,    0x27, 0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0x5c, 0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    'x',  0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  };
-
-  return table[(unsigned char)c];
-}
-
-static inline int
-unescape_char_pred(int c) {
-  switch(c) {
-    case 'b': return 8;
-    case 'f': return 12;
-    case 'n': return 10;
-    case 'r': return 13;
-    case 't': return 9;
-    case 'v': return 11;
-    case '\'': return 39;
-    case '\\': return 92;
-  }
-
-  return 0;
-}
-
-static inline int
-is_escape_char(int c) {
-  return is_control_char(c) || c == '\\' || c == '\'' || c == 0x1b || c == 0;
-}
-
-static inline int
-is_backslash_char(int c) {
-  return c == '\\';
-}
-
-//#define is_dot_char(c) ((c) == '.')0
-//#define is_backslash_char(c) ((c) == '\\')
-
-static inline int
-is_dot_char(int c) {
-  return c == '.';
-}
-
-static inline int
-is_identifier(const char* str) {
-  if(!((*str >= 'A' && *str <= 'Z') || (*str >= 'a' && *str <= 'z') || *str == '$' || *str == '_'))
-    return 0;
-
-  while(*++str)
-    if(!is_identifier_char(*str))
-      return 0;
-
-  return 1;
-}
-
-static inline int
-is_integer(const char* str) {
-  if(*str == '-')
-    ++str;
-
-  if(!(*str >= '1' && *str <= '9') && !(*str == '0' && str[1] == '\0'))
-    return 0;
-
-  while(*++str)
-    if(!is_digit_char(*str))
-      return 0;
-
-  return 1;
-}
-
-static inline size_t
-byte_count(const void* s, size_t n, char c) {
-  const uint8_t* t;
-  uint8_t ch = (uint8_t)c;
-  size_t count;
-
-  for(t = (uint8_t*)s, count = 0; n; ++t, --n)
-    if(*t == ch)
-      ++count;
-
-  return count;
-}
-
-static inline size_t
-byte_chr(const void* str, size_t len, char c) {
-  const char* s = memchr(str, c, len);
-
-  if(s)
-    return s - (const char*)str;
-
-  return len;
-}
-
-static inline size_t
-byte_rchr(const void* haystack, size_t len, char needle) {
-  const char *s, *t;
-
-  for(s = (const char*)haystack, t = s + len;;) {
-    --t;
-
-    if(s > t)
-      break;
-
-    if(*t == needle)
-      return (size_t)(t - s);
-  }
-
-  return len;
-}
-
-/*size_t
-byte_rchr(const void* str, size_t len, char c) {
-  const char* s = memrchr(str, c, len);
-  if(s)
-    return s - (const char*)str;
-  return len;
-}*/
-
-static inline size_t
-byte_chrs(const void* str, size_t len, const char needle[], size_t nl) {
-  const char *s, *t;
-
-  for(s = str, t = s + len; s != t; s++)
-    if(byte_chr(needle, nl, *s) < nl)
-      break;
-
-  return s - (const char*)str;
-}
-
-static inline int
-byte_diff(const void* a, size_t len, const void* b) {
-  size_t i;
-
-  for(i = 0; i < len; ++i) {
-    int r = ((unsigned char*)a)[i] - ((unsigned char*)b)[i];
-
-    if(r)
-      return r;
-  }
-
-  return 0;
-}
-
-static inline int
-byte_diff2(const char* a, size_t alen, const char* b, size_t blen) {
-
-  if(alen < blen)
-    return -b[alen];
-
-  if(blen < alen)
-    return a[blen];
-
-  return byte_diff(a, alen, b);
-}
-
-static inline size_t
-str_chr(const char* in, char needle) {
-  const char *t, c = needle;
-
-  for(t = in; *t; ++t)
-    if(*t == c)
-      break;
-
-  return (size_t)(t - in);
-}
-
-static inline size_t
-str_chrs(const char* in, const char needles[], size_t nn) {
-  const char* t;
-  size_t i;
-
-  for(t = in; *t; ++t)
-    for(i = 0; i < nn; i++)
-      if(*t == needles[i])
-        return (size_t)(t - in);
-
-  return (size_t)(t - in);
-}
-
-static inline size_t
-str_rchr(const char* s, char needle) {
-  const char *in, *found = 0;
-
-  for(in = s; *in; ++in)
-    if(*in == needle)
-      found = in;
-
-  return (size_t)((found ? found : in) - s);
-}
-
-static inline size_t
-str_rchrs(const char* in, const char needles[], size_t nn) {
-  const char *s, *found = 0;
-  size_t i;
-
-  for(s = in; *s; ++s)
-    for(i = 0; i < nn; ++i)
-      if(*s == needles[i])
-        found = s;
-
-  return (size_t)((found ? found : s) - in);
-}
-
-static inline int
-str_endb(const char* a, const char* x, size_t n) {
-  size_t alen = strlen(a);
-  a += alen - n;
-
-  return alen >= n && !memcmp(a, x, n);
-}
-
-/* str_ends returns 1 if the b is a suffix of a, 0 otherwise */
-static inline int
-str_ends(const char* a, const char* b) {
-  return str_endb(a, b, strlen(b));
-}
-
-static inline int
-str_startb(const char* a, const char* x, size_t len) {
-  size_t i;
-
-  for(i = 0;; i++) {
-    if(i == len)
-      return 1;
-    if(a[i] != x[i])
-      break;
-  }
-
-  return 0;
-}
-
-static inline int
-str_start(const char* a, const char* b) {
-  return str_startb(a, b, strlen(b));
-}
-
-#define str_contains(s, needle) (!!strchr((s), (needle)))
-
-char* str_escape(const char*);
-
-static inline size_t
-str_count(const char* s, char c) {
-  size_t i, count = 0;
-
-  for(i = 0; s[i]; i++)
-    if(s[i] == c)
-      ++count;
-
-  return count;
-}
-
-static inline size_t
-str_copy(char* out, const char* in) {
-  char* s;
-
-  for(s = out; (*s = *in); ++s)
-    ++in;
-
-  return (size_t)(s - out);
-}
-
-static inline size_t
-str_copyn(char* out, const char* in, size_t n) {
-  char* s;
-
-  for(s = out; n-- && (*s = *in); ++s)
-    ++in;
-
-  *s = '\0';
-  return (size_t)(s - out);
-}
-
-static inline char*
-str_ndup(const char* s, size_t n) {
-  char* r = malloc(n + 1);
-
-  if(r == NULL)
-    return NULL;
-
-  memcpy(r, s, n);
-  r[n] = '\0';
-  return r;
-}
-
-size_t str_findb(const char*, const char*, size_t);
-size_t str_find(const void*, const void*);
-
-static inline size_t
-predicate_find(const char* str, size_t len, int (*pred)(int32_t)) {
-  size_t pos;
-
-  for(pos = 0; pos < len; pos++)
-    if(pred(str[pos]))
-      break;
-
-  return pos;
-}
-
-static inline size_t
-lookup_find(const char* str, size_t len, const char table[256]) {
-  size_t pos;
-
-  for(pos = 0; pos < len; pos++)
-    if(table[(unsigned char)str[pos]])
-      break;
-
-  return pos;
-}
-
-static inline char
-escape_char_letter(char c) {
-  switch(c) {
-    case '\0': return '0';
-    case '\a': return 'a';
-    case '\b': return 'b';
-    case '\t': return 't';
-    case '\n': return 'n';
-    case '\v': return 'v';
-    case '\f': return 'f';
-    case '\r': return 'r';
-    case '\\': return '\\';
-    case '\'': return '\'';
-  }
-
-  return 0;
-}
-
-#define FMT_LONG 41  /* enough space to hold -2^127 in decimal, plus \0 */
-#define FMT_ULONG 40 /* enough space to hold 2^128 - 1 in decimal, plus \0 */
-#define FMT_8LONG 44 /* enough space to hold 2^128 - 1 in octal, plus \0 */
-#define FMT_XLONG 33 /* enough space to hold 2^128 - 1 in hexadecimal, plus \0 */
-
-size_t token_length(const char*, size_t, char delim);
-size_t fmt_ulong(char*, uint32_t);
-size_t scan_ushort(const char*, uint16_t*);
-size_t fmt_longlong(char*, int64_t);
-size_t fmt_ulonglong(char*, uint64_t);
-size_t fmt_xlonglong(char*, uint64_t);
-size_t fmt_xlonglong0(char*, uint64_t, size_t);
-size_t fmt_8long(char* dest, uint32_t i);
-size_t fmt_xlong(char* dest, uint32_t num);
-size_t fmt_xlong0(char* dest, uint32_t num, size_t n);
-size_t scan_longlong(const char*, int64_t*);
-size_t scan_int(const char*, int32_t*);
-size_t scan_uint(const char*, uint32_t*);
-size_t scan_ulonglong(const char*, uint64_t*);
-size_t scan_xlonglong(const char*, uint64_t*);
-size_t scan_8longn(const char*, size_t, uint32_t* dest);
-size_t scan_whitenskip(const char*, size_t);
-size_t scan_nonwhitenskip(const char*, size_t);
-size_t scan_line(const char*, size_t);
-size_t scan_lineskip(const char*, size_t);
-size_t scan_lineskip_escaped(const char*, size_t);
-size_t scan_eolskip(const char*, size_t);
-size_t utf8_strlen(const void*, size_t);
-wchar_t* utf8_towcs(const char*);
-char* utf8_fromwcs(const wchar_t*);
-BOOL utf16_multiword(const void*);
-int case_lowerc(int);
-int case_starts(const char*, const char*);
-int case_diffb(const void*, size_t, const void* T);
-size_t case_findb(const void*, size_t, const void* what, size_t wlen);
-size_t case_finds(const void*, const char*);
-
-static inline int
-scan_fromhex(unsigned char c) {
-  c -= '0';
-
-  if(c <= 9)
-    return c;
-
-  c &= ~0x20;
-  c -= 'A' - '0';
-
-  if(c < 6)
-    return c + 10;
-
-  return -1;
-}
-
-static inline size_t
-scan_8long(const char* src, uint32_t* dest) {
-  return scan_8longn(src, (size_t)-1, dest);
-}
-
-static inline size_t
-utf8_charlen(const char* in, size_t len) {
-  const uint8_t* next = (const void*)in;
-  int r = unicode_from_utf8((const uint8_t*)in, len, &next);
-  return r == -1 ? 0 : next - (const uint8_t*)in;
-}
-
-static inline int
-utf8_charcode(const char* in, size_t len) {
-  const uint8_t* next = (const void*)in;
-  int r = unicode_from_utf8((const uint8_t*)in, len, &next);
-  return next > in ? r : -1;
-}
-
-BOOL utf16_multiword(const void*);
-
-ssize_t write_file(const char* file, const void* buf, size_t len);
-ssize_t puts_file(const char* file, const char* s);
-
-size_t u64toa(char*, uint64_t num, int base);
-size_t i64toa(char*, int64_t num, int base);
-
-/**
- * @}
- */
-#endif /* defined(CHAR_UTILS_H) */

src/quickjs/cutils.c

@@ -1,631 +0,0 @@
-/*
- * C utilities
- *
- * Copyright (c) 2017 Fabrice Bellard
- * Copyright (c) 2018 Charlie Gordon
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-
-#include "cutils.h"
-
-void pstrcpy(char *buf, int buf_size, const char *str)
-{
-    int c;
-    char *q = buf;
-
-    if (buf_size <= 0)
-        return;
-
-    for(;;) {
-        c = *str++;
-        if (c == 0 || q >= buf + buf_size - 1)
-            break;
-        *q++ = c;
-    }
-    *q = '\0';
-}
-
-/* strcat and truncate. */
-char *pstrcat(char *buf, int buf_size, const char *s)
-{
-    int len;
-    len = strlen(buf);
-    if (len < buf_size)
-        pstrcpy(buf + len, buf_size - len, s);
-    return buf;
-}
-
-int strstart(const char *str, const char *val, const char **ptr)
-{
-    const char *p, *q;
-    p = str;
-    q = val;
-    while (*q != '\0') {
-        if (*p != *q)
-            return 0;
-        p++;
-        q++;
-    }
-    if (ptr)
-        *ptr = p;
-    return 1;
-}
-
-int has_suffix(const char *str, const char *suffix)
-{
-    size_t len = strlen(str);
-    size_t slen = strlen(suffix);
-    return (len >= slen && !memcmp(str + len - slen, suffix, slen));
-}
-
-/* Dynamic buffer package */
-
-static void *dbuf_default_realloc(void *opaque, void *ptr, size_t size)
-{
-    return realloc(ptr, size);
-}
-
-void dbuf_init2(DynBuf *s, void *opaque, DynBufReallocFunc *realloc_func)
-{
-    memset(s, 0, sizeof(*s));
-    if (!realloc_func)
-        realloc_func = dbuf_default_realloc;
-    s->opaque = opaque;
-    s->realloc_func = realloc_func;
-}
-
-void dbuf_init(DynBuf *s)
-{
-    dbuf_init2(s, NULL, NULL);
-}
-
-/* return < 0 if error */
-int dbuf_realloc(DynBuf *s, size_t new_size)
-{
-    size_t size;
-    uint8_t *new_buf;
-    if (new_size > s->allocated_size) {
-        if (s->error)
-            return -1;
-        size = s->allocated_size * 3 / 2;
-        if (size > new_size)
-            new_size = size;
-        new_buf = s->realloc_func(s->opaque, s->buf, new_size);
-        if (!new_buf) {
-            s->error = TRUE;
-            return -1;
-        }
-        s->buf = new_buf;
-        s->allocated_size = new_size;
-    }
-    return 0;
-}
-
-int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len)
-{
-    size_t end;
-    end = offset + len;
-    if (dbuf_realloc(s, end))
-        return -1;
-    memcpy(s->buf + offset, data, len);
-    if (end > s->size)
-        s->size = end;
-    return 0;
-}
-
-int dbuf_put(DynBuf *s, const uint8_t *data, size_t len)
-{
-    if (unlikely((s->size + len) > s->allocated_size)) {
-        if (dbuf_realloc(s, s->size + len))
-            return -1;
-    }
-    memcpy_no_ub(s->buf + s->size, data, len);
-    s->size += len;
-    return 0;
-}
-
-int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
-{
-    if (unlikely((s->size + len) > s->allocated_size)) {
-        if (dbuf_realloc(s, s->size + len))
-            return -1;
-    }
-    memcpy(s->buf + s->size, s->buf + offset, len);
-    s->size += len;
-    return 0;
-}
-
-int dbuf_putc(DynBuf *s, uint8_t c)
-{
-    return dbuf_put(s, &c, 1);
-}
-
-int dbuf_putstr(DynBuf *s, const char *str)
-{
-    return dbuf_put(s, (const uint8_t *)str, strlen(str));
-}
-
-int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
-                                                      const char *fmt, ...)
-{
-    va_list ap;
-    char buf[128];
-    int len;
-
-    va_start(ap, fmt);
-    len = vsnprintf(buf, sizeof(buf), fmt, ap);
-    va_end(ap);
-    if (len < sizeof(buf)) {
-        /* fast case */
-        return dbuf_put(s, (uint8_t *)buf, len);
-    } else {
-        if (dbuf_realloc(s, s->size + len + 1))
-            return -1;
-        va_start(ap, fmt);
-        vsnprintf((char *)(s->buf + s->size), s->allocated_size - s->size,
-                  fmt, ap);
-        va_end(ap);
-        s->size += len;
-    }
-    return 0;
-}
-
-void dbuf_free(DynBuf *s)
-{
-    /* we test s->buf as a fail safe to avoid crashing if dbuf_free()
-       is called twice */
-    if (s->buf) {
-        s->realloc_func(s->opaque, s->buf, 0);
-    }
-    memset(s, 0, sizeof(*s));
-}
-
-/* Note: at most 31 bits are encoded. At most UTF8_CHAR_LEN_MAX bytes
-   are output. */
-int unicode_to_utf8(uint8_t *buf, unsigned int c)
-{
-    uint8_t *q = buf;
-
-    if (c < 0x80) {
-        *q++ = c;
-    } else {
-        if (c < 0x800) {
-            *q++ = (c >> 6) | 0xc0;
-        } else {
-            if (c < 0x10000) {
-                *q++ = (c >> 12) | 0xe0;
-            } else {
-                if (c < 0x00200000) {
-                    *q++ = (c >> 18) | 0xf0;
-                } else {
-                    if (c < 0x04000000) {
-                        *q++ = (c >> 24) | 0xf8;
-                    } else if (c < 0x80000000) {
-                        *q++ = (c >> 30) | 0xfc;
-                        *q++ = ((c >> 24) & 0x3f) | 0x80;
-                    } else {
-                        return 0;
-                    }
-                    *q++ = ((c >> 18) & 0x3f) | 0x80;
-                }
-                *q++ = ((c >> 12) & 0x3f) | 0x80;
-            }
-            *q++ = ((c >> 6) & 0x3f) | 0x80;
-        }
-        *q++ = (c & 0x3f) | 0x80;
-    }
-    return q - buf;
-}
-
-static const unsigned int utf8_min_code[5] = {
-    0x80, 0x800, 0x10000, 0x00200000, 0x04000000,
-};
-
-static const unsigned char utf8_first_code_mask[5] = {
-    0x1f, 0xf, 0x7, 0x3, 0x1,
-};
-
-/* return -1 if error. *pp is not updated in this case. max_len must
-   be >= 1. The maximum length for a UTF8 byte sequence is 6 bytes. */
-int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp)
-{
-    int l, c, b, i;
-
-    c = *p++;
-    if (c < 0x80) {
-        *pp = p;
-        return c;
-    }
-    switch(c) {
-    case 0xc0: case 0xc1: case 0xc2: case 0xc3:
-    case 0xc4: case 0xc5: case 0xc6: case 0xc7:
-    case 0xc8: case 0xc9: case 0xca: case 0xcb:
-    case 0xcc: case 0xcd: case 0xce: case 0xcf:
-    case 0xd0: case 0xd1: case 0xd2: case 0xd3:
-    case 0xd4: case 0xd5: case 0xd6: case 0xd7:
-    case 0xd8: case 0xd9: case 0xda: case 0xdb:
-    case 0xdc: case 0xdd: case 0xde: case 0xdf:
-        l = 1;
-        break;
-    case 0xe0: case 0xe1: case 0xe2: case 0xe3:
-    case 0xe4: case 0xe5: case 0xe6: case 0xe7:
-    case 0xe8: case 0xe9: case 0xea: case 0xeb:
-    case 0xec: case 0xed: case 0xee: case 0xef:
-        l = 2;
-        break;
-    case 0xf0: case 0xf1: case 0xf2: case 0xf3:
-    case 0xf4: case 0xf5: case 0xf6: case 0xf7:
-        l = 3;
-        break;
-    case 0xf8: case 0xf9: case 0xfa: case 0xfb:
-        l = 4;
-        break;
-    case 0xfc: case 0xfd:
-        l = 5;
-        break;
-    default:
-        return -1;
-    }
-    /* check that we have enough characters */
-    if (l > (max_len - 1))
-        return -1;
-    c &= utf8_first_code_mask[l - 1];
-    for(i = 0; i < l; i++) {
-        b = *p++;
-        if (b < 0x80 || b >= 0xc0)
-            return -1;
-        c = (c << 6) | (b & 0x3f);
-    }
-    if (c < utf8_min_code[l - 1])
-        return -1;
-    *pp = p;
-    return c;
-}
-
-#if 0
-
-#if defined(EMSCRIPTEN) || defined(__ANDROID__)
-
-static void *rqsort_arg;
-static int (*rqsort_cmp)(const void *, const void *, void *);
-
-static int rqsort_cmp2(const void *p1, const void *p2)
-{
-    return rqsort_cmp(p1, p2, rqsort_arg);
-}
-
-/* not reentrant, but not needed with emscripten */
-void rqsort(void *base, size_t nmemb, size_t size,
-            int (*cmp)(const void *, const void *, void *),
-            void *arg)
-{
-    rqsort_arg = arg;
-    rqsort_cmp = cmp;
-    qsort(base, nmemb, size, rqsort_cmp2);
-}
-
-#endif
-
-#else
-
-typedef void (*exchange_f)(void *a, void *b, size_t size);
-typedef int (*cmp_f)(const void *, const void *, void *opaque);
-
-static void exchange_bytes(void *a, void *b, size_t size) {
-    uint8_t *ap = (uint8_t *)a;
-    uint8_t *bp = (uint8_t *)b;
-
-    while (size-- != 0) {
-        uint8_t t = *ap;
-        *ap++ = *bp;
-        *bp++ = t;
-    }
-}
-
-static void exchange_one_byte(void *a, void *b, size_t size) {
-    uint8_t *ap = (uint8_t *)a;
-    uint8_t *bp = (uint8_t *)b;
-    uint8_t t = *ap;
-    *ap = *bp;
-    *bp = t;
-}
-
-static void exchange_int16s(void *a, void *b, size_t size) {
-    uint16_t *ap = (uint16_t *)a;
-    uint16_t *bp = (uint16_t *)b;
-
-    for (size /= sizeof(uint16_t); size-- != 0;) {
-        uint16_t t = *ap;
-        *ap++ = *bp;
-        *bp++ = t;
-    }
-}
-
-static void exchange_one_int16(void *a, void *b, size_t size) {
-    uint16_t *ap = (uint16_t *)a;
-    uint16_t *bp = (uint16_t *)b;
-    uint16_t t = *ap;
-    *ap = *bp;
-    *bp = t;
-}
-
-static void exchange_int32s(void *a, void *b, size_t size) {
-    uint32_t *ap = (uint32_t *)a;
-    uint32_t *bp = (uint32_t *)b;
-
-    for (size /= sizeof(uint32_t); size-- != 0;) {
-        uint32_t t = *ap;
-        *ap++ = *bp;
-        *bp++ = t;
-    }
-}
-
-static void exchange_one_int32(void *a, void *b, size_t size) {
-    uint32_t *ap = (uint32_t *)a;
-    uint32_t *bp = (uint32_t *)b;
-    uint32_t t = *ap;
-    *ap = *bp;
-    *bp = t;
-}
-
-static void exchange_int64s(void *a, void *b, size_t size) {
-    uint64_t *ap = (uint64_t *)a;
-    uint64_t *bp = (uint64_t *)b;
-
-    for (size /= sizeof(uint64_t); size-- != 0;) {
-        uint64_t t = *ap;
-        *ap++ = *bp;
-        *bp++ = t;
-    }
-}
-
-static void exchange_one_int64(void *a, void *b, size_t size) {
-    uint64_t *ap = (uint64_t *)a;
-    uint64_t *bp = (uint64_t *)b;
-    uint64_t t = *ap;
-    *ap = *bp;
-    *bp = t;
-}
-
-static void exchange_int128s(void *a, void *b, size_t size) {
-    uint64_t *ap = (uint64_t *)a;
-    uint64_t *bp = (uint64_t *)b;
-
-    for (size /= sizeof(uint64_t) * 2; size-- != 0; ap += 2, bp += 2) {
-        uint64_t t = ap[0];
-        uint64_t u = ap[1];
-        ap[0] = bp[0];
-        ap[1] = bp[1];
-        bp[0] = t;
-        bp[1] = u;
-    }
-}
-
-static void exchange_one_int128(void *a, void *b, size_t size) {
-    uint64_t *ap = (uint64_t *)a;
-    uint64_t *bp = (uint64_t *)b;
-    uint64_t t = ap[0];
-    uint64_t u = ap[1];
-    ap[0] = bp[0];
-    ap[1] = bp[1];
-    bp[0] = t;
-    bp[1] = u;
-}
-
-static inline exchange_f exchange_func(const void *base, size_t size) {
-    switch (((uintptr_t)base | (uintptr_t)size) & 15) {
-    case 0:
-        if (size == sizeof(uint64_t) * 2)
-            return exchange_one_int128;
-        else
-            return exchange_int128s;
-    case 8:
-        if (size == sizeof(uint64_t))
-            return exchange_one_int64;
-        else
-            return exchange_int64s;
-    case 4:
-    case 12:
-        if (size == sizeof(uint32_t))
-            return exchange_one_int32;
-        else
-            return exchange_int32s;
-    case 2:
-    case 6:
-    case 10:
-    case 14:
-        if (size == sizeof(uint16_t))
-            return exchange_one_int16;
-        else
-            return exchange_int16s;
-    default:
-        if (size == 1)
-            return exchange_one_byte;
-        else
-            return exchange_bytes;
-    }
-}
-
-static void heapsortx(void *base, size_t nmemb, size_t size, cmp_f cmp, void *opaque)
-{
-    uint8_t *basep = (uint8_t *)base;
-    size_t i, n, c, r;
-    exchange_f swap = exchange_func(base, size);
-
-    if (nmemb > 1) {
-        i = (nmemb / 2) * size;
-        n = nmemb * size;
-
-        while (i > 0) {
-            i -= size;
-            for (r = i; (c = r * 2 + size) < n; r = c) {
-                if (c < n - size && cmp(basep + c, basep + c + size, opaque) <= 0)
-                    c += size;
-                if (cmp(basep + r, basep + c, opaque) > 0)
-                    break;
-                swap(basep + r, basep + c, size);
-            }
-        }
-        for (i = n - size; i > 0; i -= size) {
-            swap(basep, basep + i, size);
-
-            for (r = 0; (c = r * 2 + size) < i; r = c) {
-                if (c < i - size && cmp(basep + c, basep + c + size, opaque) <= 0)
-                    c += size;
-                if (cmp(basep + r, basep + c, opaque) > 0)
-                    break;
-                swap(basep + r, basep + c, size);
-            }
-        }
-    }
-}
-
-static inline void *med3(void *a, void *b, void *c, cmp_f cmp, void *opaque)
-{
-    return cmp(a, b, opaque) < 0 ?
-        (cmp(b, c, opaque) < 0 ? b : (cmp(a, c, opaque) < 0 ? c : a )) :
-        (cmp(b, c, opaque) > 0 ? b : (cmp(a, c, opaque) < 0 ? a : c ));
-}
-
-/* pointer based version with local stack and insertion sort threshhold */
-void rqsort(void *base, size_t nmemb, size_t size, cmp_f cmp, void *opaque)
-{
-    struct { uint8_t *base; size_t count; int depth; } stack[50], *sp = stack;
-    uint8_t *ptr, *pi, *pj, *plt, *pgt, *top, *m;
-    size_t m4, i, lt, gt, span, span2;
-    int c, depth;
-    exchange_f swap = exchange_func(base, size);
-    exchange_f swap_block = exchange_func(base, size | 128);
-
-    if (nmemb < 2 || size <= 0)
-        return;
-
-    sp->base = (uint8_t *)base;
-    sp->count = nmemb;
-    sp->depth = 0;
-    sp++;
-
-    while (sp > stack) {
-        sp--;
-        ptr = sp->base;
-        nmemb = sp->count;
-        depth = sp->depth;
-
-        while (nmemb > 6) {
-            if (++depth > 50) {
-                /* depth check to ensure worst case logarithmic time */
-                heapsortx(ptr, nmemb, size, cmp, opaque);
-                nmemb = 0;
-                break;
-            }
-            /* select median of 3 from 1/4, 1/2, 3/4 positions */
-            /* should use median of 5 or 9? */
-            m4 = (nmemb >> 2) * size;
-            m = med3(ptr + m4, ptr + 2 * m4, ptr + 3 * m4, cmp, opaque);
-            swap(ptr, m, size);  /* move the pivot to the start or the array */
-            i = lt = 1;
-            pi = plt = ptr + size;
-            gt = nmemb;
-            pj = pgt = top = ptr + nmemb * size;
-            for (;;) {
-                while (pi < pj && (c = cmp(ptr, pi, opaque)) >= 0) {
-                    if (c == 0) {
-                        swap(plt, pi, size);
-                        lt++;
-                        plt += size;
-                    }
-                    i++;
-                    pi += size;
-                }
-                while (pi < (pj -= size) && (c = cmp(ptr, pj, opaque)) <= 0) {
-                    if (c == 0) {
-                        gt--;
-                        pgt -= size;
-                        swap(pgt, pj, size);
-                    }
-                }
-                if (pi >= pj)
-                    break;
-                swap(pi, pj, size);
-                i++;
-                pi += size;
-            }
-            /* array has 4 parts:
-             * from 0 to lt excluded: elements identical to pivot
-             * from lt to pi excluded: elements smaller than pivot
-             * from pi to gt excluded: elements greater than pivot
-             * from gt to n excluded: elements identical to pivot
-             */
-            /* move elements identical to pivot in the middle of the array: */
-            /* swap values in ranges [0..lt[ and [i-lt..i[
-               swapping the smallest span between lt and i-lt is sufficient
-             */
-            span = plt - ptr;
-            span2 = pi - plt;
-            lt = i - lt;
-            if (span > span2)
-                span = span2;
-            swap_block(ptr, pi - span, span);
-            /* swap values in ranges [gt..top[ and [i..top-(top-gt)[
-               swapping the smallest span between top-gt and gt-i is sufficient
-             */
-            span = top - pgt;
-            span2 = pgt - pi;
-            pgt = top - span2;
-            gt = nmemb - (gt - i);
-            if (span > span2)
-                span = span2;
-            swap_block(pi, top - span, span);
-
-            /* now array has 3 parts:
-             * from 0 to lt excluded: elements smaller than pivot
-             * from lt to gt excluded: elements identical to pivot
-             * from gt to n excluded: elements greater than pivot
-             */
-            /* stack the larger segment and keep processing the smaller one
-               to minimize stack use for pathological distributions */
-            if (lt > nmemb - gt) {
-                sp->base = ptr;
-                sp->count = lt;
-                sp->depth = depth;
-                sp++;
-                ptr = pgt;
-                nmemb -= gt;
-            } else {
-                sp->base = pgt;
-                sp->count = nmemb - gt;
-                sp->depth = depth;
-                sp++;
-                nmemb = lt;
-            }
-        }
-        /* Use insertion sort for small fragments */
-        for (pi = ptr + size, top = ptr + nmemb * size; pi < top; pi += size) {
-            for (pj = pi; pj > ptr && cmp(pj - size, pj, opaque) > 0; pj -= size)
-                swap(pj, pj - size, size);
-        }
-    }
-}
-
-#endif

src/quickjs/cutils.h

@@ -1,341 +0,0 @@
-/*
- * C utilities
- *
- * Copyright (c) 2017 Fabrice Bellard
- * Copyright (c) 2018 Charlie Gordon
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#ifndef CUTILS_H
-#define CUTILS_H
-
-#include <stdlib.h>
-#include <string.h>
-#include <inttypes.h>
-
-#define likely(x)       __builtin_expect(!!(x), 1)
-#define unlikely(x)     __builtin_expect(!!(x), 0)
-#define force_inline inline __attribute__((always_inline))
-#define no_inline __attribute__((noinline))
-#define __maybe_unused __attribute__((unused))
-
-#define xglue(x, y) x ## y
-#define glue(x, y) xglue(x, y)
-#define stringify(s)    tostring(s)
-#define tostring(s)     #s
-
-#ifndef offsetof
-#define offsetof(type, field) ((size_t) &((type *)0)->field)
-#endif
-#ifndef countof
-#define countof(x) (sizeof(x) / sizeof((x)[0]))
-#endif
-#ifndef container_of
-/* return the pointer of type 'type *' containing 'ptr' as field 'member' */
-#define container_of(ptr, type, member) ((type *)((uint8_t *)(ptr) - offsetof(type, member)))
-#endif
-
-typedef int BOOL;
-
-#ifndef FALSE
-enum {
-    FALSE = 0,
-    TRUE = 1,
-};
-#endif
-
-void pstrcpy(char *buf, int buf_size, const char *str);
-char *pstrcat(char *buf, int buf_size, const char *s);
-int strstart(const char *str, const char *val, const char **ptr);
-int has_suffix(const char *str, const char *suffix);
-
-/* Prevent UB when n == 0 and (src == NULL or dest == NULL) */
-static inline void memcpy_no_ub(void *dest, const void *src, size_t n) {
-    if (n)
-        memcpy(dest, src, n);
-}
-
-static inline int max_int(int a, int b)
-{
-    if (a > b)
-        return a;
-    else
-        return b;
-}
-
-static inline int min_int(int a, int b)
-{
-    if (a < b)
-        return a;
-    else
-        return b;
-}
-
-static inline uint32_t max_uint32(uint32_t a, uint32_t b)
-{
-    if (a > b)
-        return a;
-    else
-        return b;
-}
-
-static inline uint32_t min_uint32(uint32_t a, uint32_t b)
-{
-    if (a < b)
-        return a;
-    else
-        return b;
-}
-
-static inline int64_t max_int64(int64_t a, int64_t b)
-{
-    if (a > b)
-        return a;
-    else
-        return b;
-}
-
-static inline int64_t min_int64(int64_t a, int64_t b)
-{
-    if (a < b)
-        return a;
-    else
-        return b;
-}
-
-/* WARNING: undefined if a = 0 */
-static inline int clz32(unsigned int a)
-{
-    return __builtin_clz(a);
-}
-
-/* WARNING: undefined if a = 0 */
-static inline int clz64(uint64_t a)
-{
-    return __builtin_clzll(a);
-}
-
-/* WARNING: undefined if a = 0 */
-static inline int ctz32(unsigned int a)
-{
-    return __builtin_ctz(a);
-}
-
-/* WARNING: undefined if a = 0 */
-static inline int ctz64(uint64_t a)
-{
-    return __builtin_ctzll(a);
-}
-
-struct __attribute__((packed)) packed_u64 {
-    uint64_t v;
-};
-
-struct __attribute__((packed)) packed_u32 {
-    uint32_t v;
-};
-
-struct __attribute__((packed)) packed_u16 {
-    uint16_t v;
-};
-
-static inline uint64_t get_u64(const uint8_t *tab)
-{
-    return ((const struct packed_u64 *)tab)->v;
-}
-
-static inline int64_t get_i64(const uint8_t *tab)
-{
-    return (int64_t)((const struct packed_u64 *)tab)->v;
-}
-
-static inline void put_u64(uint8_t *tab, uint64_t val)
-{
-    ((struct packed_u64 *)tab)->v = val;
-}
-
-static inline uint32_t get_u32(const uint8_t *tab)
-{
-    return ((const struct packed_u32 *)tab)->v;
-}
-
-static inline int32_t get_i32(const uint8_t *tab)
-{
-    return (int32_t)((const struct packed_u32 *)tab)->v;
-}
-
-static inline void put_u32(uint8_t *tab, uint32_t val)
-{
-    ((struct packed_u32 *)tab)->v = val;
-}
-
-static inline uint32_t get_u16(const uint8_t *tab)
-{
-    return ((const struct packed_u16 *)tab)->v;
-}
-
-static inline int32_t get_i16(const uint8_t *tab)
-{
-    return (int16_t)((const struct packed_u16 *)tab)->v;
-}
-
-static inline void put_u16(uint8_t *tab, uint16_t val)
-{
-    ((struct packed_u16 *)tab)->v = val;
-}
-
-static inline uint32_t get_u8(const uint8_t *tab)
-{
-    return *tab;
-}
-
-static inline int32_t get_i8(const uint8_t *tab)
-{
-    return (int8_t)*tab;
-}
-
-static inline void put_u8(uint8_t *tab, uint8_t val)
-{
-    *tab = val;
-}
-
-#ifndef bswap16
-static inline uint16_t bswap16(uint16_t x)
-{
-    return (x >> 8) | (x << 8);
-}
-#endif
-
-#ifndef bswap32
-static inline uint32_t bswap32(uint32_t v)
-{
-    return ((v & 0xff000000) >> 24) | ((v & 0x00ff0000) >>  8) |
-        ((v & 0x0000ff00) <<  8) | ((v & 0x000000ff) << 24);
-}
-#endif
-
-#ifndef bswap64
-static inline uint64_t bswap64(uint64_t v)
-{
-    return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) |
-        ((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) |
-        ((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) |
-        ((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) |
-        ((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) |
-        ((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) |
-        ((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) |
-        ((v & ((uint64_t)0xff << (0 * 8))) << (7 * 8));
-}
-#endif
-
-/* XXX: should take an extra argument to pass slack information to the caller */
-typedef void *DynBufReallocFunc(void *opaque, void *ptr, size_t size);
-
-typedef struct DynBuf {
-    uint8_t *buf;
-    size_t size;
-    size_t allocated_size;
-    BOOL error; /* true if a memory allocation error occurred */
-    DynBufReallocFunc *realloc_func;
-    void *opaque; /* for realloc_func */
-} DynBuf;
-
-void dbuf_init(DynBuf *s);
-void dbuf_init2(DynBuf *s, void *opaque, DynBufReallocFunc *realloc_func);
-int dbuf_realloc(DynBuf *s, size_t new_size);
-int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len);
-int dbuf_put(DynBuf *s, const uint8_t *data, size_t len);
-int dbuf_put_self(DynBuf *s, size_t offset, size_t len);
-int dbuf_putc(DynBuf *s, uint8_t c);
-int dbuf_putstr(DynBuf *s, const char *str);
-static inline int dbuf_put_u16(DynBuf *s, uint16_t val)
-{
-    return dbuf_put(s, (uint8_t *)&val, 2);
-}
-static inline int dbuf_put_u32(DynBuf *s, uint32_t val)
-{
-    return dbuf_put(s, (uint8_t *)&val, 4);
-}
-static inline int dbuf_put_u64(DynBuf *s, uint64_t val)
-{
-    return dbuf_put(s, (uint8_t *)&val, 8);
-}
-int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
-                                                      const char *fmt, ...);
-void dbuf_free(DynBuf *s);
-static inline BOOL dbuf_error(DynBuf *s) {
-    return s->error;
-}
-static inline void dbuf_set_error(DynBuf *s)
-{
-    s->error = TRUE;
-}
-
-#define UTF8_CHAR_LEN_MAX 6
-
-int unicode_to_utf8(uint8_t *buf, unsigned int c);
-int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp);
-
-static inline BOOL is_surrogate(uint32_t c)
-{
-    return (c >> 11) == (0xD800 >> 11); // 0xD800-0xDFFF
-}
-
-static inline BOOL is_hi_surrogate(uint32_t c)
-{
-    return (c >> 10) == (0xD800 >> 10); // 0xD800-0xDBFF
-}
-
-static inline BOOL is_lo_surrogate(uint32_t c)
-{
-    return (c >> 10) == (0xDC00 >> 10); // 0xDC00-0xDFFF
-}
-
-static inline uint32_t get_hi_surrogate(uint32_t c)
-{
-    return (c >> 10) - (0x10000 >> 10) + 0xD800;
-}
-
-static inline uint32_t get_lo_surrogate(uint32_t c)
-{
-    return (c & 0x3FF) | 0xDC00;
-}
-
-static inline uint32_t from_surrogate(uint32_t hi, uint32_t lo)
-{
-    return 0x10000 + 0x400 * (hi - 0xD800) + (lo - 0xDC00);
-}
-
-static inline int from_hex(int c)
-{
-    if (c >= '0' && c <= '9')
-        return c - '0';
-    else if (c >= 'A' && c <= 'F')
-        return c - 'A' + 10;
-    else if (c >= 'a' && c <= 'f')
-        return c - 'a' + 10;
-    else
-        return -1;
-}
-
-void rqsort(void *base, size_t nmemb, size_t size,
-            int (*cmp)(const void *, const void *, void *),
-            void *arg);
-
-#endif  /* CUTILS_H */

src/quickjs/debug.c

@@ -1,483 +0,0 @@
-#define _IN_DEBUG_C 1
-#include "debug.h"
-#include <quickjs.h>
-#include <list.h>
-#include <cutils.h>
-#include <assert.h>
-#include "defines.h"
-#include <string.h>
-#include <stdlib.h>
-
-/**
- * \addtogroup debug
- * @{
- */
-struct alloc_block {
-  struct list_head link;
-  const char* file;
-  int line;
-  size_t size;
-};
-
-#define ALLOC_BLOCK_SIZE sizeof(struct alloc_block)
-#define ALLOC_BLOCK(p) (((struct alloc_block*)(p)) - 1)
-#define ALLOC_PTR struct alloc_block*
-
-#undef malloc
-#undef calloc
-#undef realloc
-#undef strdup
-#undef free
-#undef js_malloc
-#undef js_mallocz
-#undef js_realloc
-#undef js_strdup
-#undef js_strndup
-#undef js_free
-#undef js_malloc_usable_size
-#undef js_malloc_rt
-#undef js_mallocz_rt
-#undef js_realloc_rt
-#undef js_free_rt
-#undef js_malloc_usable_size_rt
-
-thread_local struct list_head alloc_block_list = {0, 0};
-
-static inline void
-add_to_list(struct list_head* el, struct list_head* head) {
-  if(alloc_block_list.prev == 0 && alloc_block_list.next == 0)
-    init_list_head(&alloc_block_list);
-
-  list_add_tail(el, head);
-}
-
-int64_t
-check_pointer(void* p) {
-  ALLOC_PTR ptr = ALLOC_BLOCK(p);
-  struct list_head* link;
-  int64_t ret = 0;
-  list_for_each(link, &alloc_block_list) {
-    if(link == &ptr->link)
-      return ret;
-    ret++;
-  }
-  // assert(0);
-  return -1;
-}
-
-void*
-debug_malloc(size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = malloc(n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_calloc(size_t m, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  m *= n;
-  n = 1;
-
-  if((ptr = calloc(m + ALLOC_BLOCK_SIZE, 1))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_realloc(void* p, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if(p) {
-
-    check_pointer(p);
-
-    ptr = ALLOC_BLOCK(p);
-    list_del(&ptr->link);
-
-    if(n == 0) {
-      free(ptr);
-      return 0;
-    }
-
-    ptr = realloc(ptr, n + ALLOC_BLOCK_SIZE);
-  } else {
-    ptr = malloc(n + ALLOC_BLOCK_SIZE);
-  }
-
-  if(ptr) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_strdup(const char* s, const char* file, int line) {
-  ALLOC_PTR ptr;
-  size_t len = strlen(s);
-
-  if((ptr = malloc(len + 1 + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = len + 1;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-
-    memcpy(&ptr[1], s, len + 1);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void
-debug_free(void* p, const char* file, int line) {
-  ALLOC_PTR ptr = ALLOC_BLOCK(p);
-
-  list_del(&ptr->link);
-
-  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
-
-  free(ptr);
-}
-
-void*
-debug_js_malloc(JSContext* ctx, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_malloc(ctx, n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_mallocz(JSContext* ctx, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_mallocz(ctx, n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_realloc(JSContext* ctx, void* p, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if(p) {
-
-    check_pointer(p);
-
-    ptr = ALLOC_BLOCK(p);
-    list_del(&ptr->link);
-
-    if(n == 0) {
-      js_free(ctx, ptr);
-      return 0;
-    }
-
-    ptr = js_realloc(ctx, ptr, n + ALLOC_BLOCK_SIZE);
-  } else {
-    ptr = js_malloc(ctx, n + ALLOC_BLOCK_SIZE);
-  }
-
-  if(ptr) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_realloc2(JSContext* ctx, void* p, size_t size, size_t* pslack, const char* file, int line) {
-  void* ptr;
-
-  if((ptr = debug_js_realloc(ctx, p, size, file, line))) {
-    if(pslack) {
-      size_t new_size = debug_js_malloc_usable_size(ctx, ptr, file, line);
-      *pslack = (new_size > size) ? new_size - size : 0;
-    }
-  }
-  return ptr;
-}
-
-void*
-debug_js_strdup(JSContext* ctx, const char* s, const char* file, int line) {
-  ALLOC_PTR ptr;
-  size_t len = strlen(s);
-
-  if((ptr = js_malloc(ctx, len + 1 + ALLOC_BLOCK_SIZE))) {
-    char* p = (char*)&ptr[1];
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = len + 1;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-
-    memcpy(p, s, len + 1);
-    return p;
-  }
-  return 0;
-}
-
-void*
-debug_js_strndup(JSContext* ctx, const char* s, size_t len, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_malloc(ctx, len + 1 + ALLOC_BLOCK_SIZE))) {
-    char* p = (char*)&ptr[1];
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = len + 1;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-
-    memcpy(p, s, len);
-    p[len] = '\0';
-
-    return p;
-  }
-  return 0;
-}
-
-size_t
-debug_js_malloc_usable_size(JSContext* ctx, const void* p, const char* file, int line) {
-  ALLOC_PTR ptr = ALLOC_BLOCK(p);
-
-  return js_malloc_usable_size(ctx, ptr) - ALLOC_BLOCK_SIZE;
-}
-
-void
-debug_js_free(JSContext* ctx, void* p, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  check_pointer(p);
-  ptr = ALLOC_BLOCK(p);
-  list_del(&ptr->link);
-
-  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
-
-  js_free(ctx, ptr);
-}
-
-void*
-debug_js_malloc_rt(JSRuntime* rt, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_malloc_rt(rt, n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_mallocz_rt(JSRuntime* rt, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if((ptr = js_mallocz_rt(rt, n + ALLOC_BLOCK_SIZE))) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-void*
-debug_js_realloc_rt(JSRuntime* rt, void* p, size_t n, const char* file, int line) {
-  ALLOC_PTR ptr;
-
-  if(p) {
-    check_pointer(p);
-
-    ptr = ALLOC_BLOCK(p);
-    list_del(&ptr->link);
-    if(n == 0) {
-      js_free_rt(rt, ptr);
-      return 0;
-    }
-    ptr = js_realloc_rt(rt, ptr, n + ALLOC_BLOCK_SIZE);
-  } else {
-    ptr = js_malloc_rt(rt, n + ALLOC_BLOCK_SIZE);
-  }
-
-  if(ptr) {
-    ptr->file = file;
-    ptr->line = line;
-    ptr->size = n;
-
-    add_to_list(&ptr->link, &alloc_block_list);
-    return &ptr[1];
-  }
-  return 0;
-}
-
-size_t
-debug_js_malloc_usable_size_rt(JSRuntime* rt, const void* p, const char* file, int line) {
-  ALLOC_PTR ptr = ALLOC_BLOCK(p);
-
-  return js_malloc_usable_size_rt(rt, ptr) - ALLOC_BLOCK_SIZE;
-}
-
-void
-debug_js_free_rt(JSRuntime* rt, void* p, const char* file, int line) {
-  ALLOC_PTR ptr;
-  check_pointer(p);
-
-  ptr = ALLOC_BLOCK(p);
-
-  // printf("debug_js_free_rt %p\n", p);
-
-  list_del(&ptr->link);
-
-  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
-
-  js_free_rt(rt, ptr);
-}
-
-#undef malloc
-#undef calloc
-#undef realloc
-#undef strdup
-#undef free
-#undef js_malloc
-#undef js_mallocz
-#undef js_realloc
-#undef js_strdup
-#undef js_strndup
-#undef js_malloc_usable_size
-#undef js_free
-#undef js_malloc_rt
-#undef js_mallocz_rt
-#undef js_realloc_rt
-#undef js_malloc_usable_size_rt
-#undef js_free_rt
-
-void*
-orig_malloc(size_t size) {
-  return malloc(size);
-}
-
-void*
-orig_calloc(size_t nelem, size_t elemsz) {
-  return calloc(nelem, elemsz);
-}
-
-void*
-orig_realloc(void* ptr, size_t size) {
-  return realloc(ptr, size);
-}
-
-void*
-orig_strdup(const char* str) {
-  return strdup(str);
-}
-
-void
-orig_free(void* ptr) {
-  free(ptr);
-}
-
-void*
-orig_js_malloc(JSContext* ctx, size_t size) {
-  return js_malloc(ctx, size);
-}
-
-void*
-orig_js_mallocz(JSContext* ctx, size_t size) {
-  return js_mallocz(ctx, size);
-}
-
-void*
-orig_js_realloc(JSContext* ctx, void* p, size_t size) {
-  return js_realloc(ctx, p, size);
-}
-
-void*
-orig_js_strdup(JSContext* ctx, const char* str) {
-  return js_strdup(ctx, str);
-}
-
-void*
-orig_js_strndup(JSContext* ctx, const char* str, size_t size) {
-  return js_strndup(ctx, str, size);
-}
-
-size_t
-orig_js_malloc_usable_size(JSContext* ctx, const void* p) {
-  return js_malloc_usable_size(ctx, p);
-}
-
-void
-orig_js_free(JSContext* ctx, void* p) {
-  return js_free(ctx, p);
-}
-
-void*
-orig_js_malloc_rt(JSRuntime* rt, size_t size) {
-  return js_malloc_rt(rt, size);
-}
-
-void*
-orig_js_mallocz_rt(JSRuntime* rt, size_t size) {
-  return js_mallocz_rt(rt, size);
-}
-
-void*
-orig_js_realloc_rt(JSRuntime* rt, void* p, size_t size) {
-  return js_realloc_rt(rt, p, size);
-}
-
-size_t
-orig_js_malloc_usable_size_rt(JSRuntime* rt, const void* p) {
-  return js_malloc_usable_size_rt(rt, p);
-}
-
-void
-orig_js_free_rt(JSRuntime* rt, void* p) {
-  return js_free_rt(rt, p);
-}
-
-/**
- * @}
- */

src/quickjs/debug.h

@@ -1,165 +0,0 @@
-#ifndef DEBUG_H
-#define DEBUG_H
-
-#include <quickjs.h>
-#include <cutils.h>
-#include "defines.h"
-
-#ifndef QUICKJS_H
-#error "quickjs.h not included"
-#endif
-
-/**
- * \defgroup debug debug: Debugging helpers
- * @{
- */
-
-extern thread_local struct list_head alloc_block_list;
-
-int64_t check_pointer(void*);
-void* debug_malloc(size_t, const char*, int);
-void* debug_calloc(size_t, size_t, const char*, int line);
-void* debug_realloc(void*, size_t, const char*, int line);
-void* debug_strdup(const char*, const char*, int);
-void debug_free(void*, const char*, int);
-void* debug_js_malloc(JSContext*, size_t, const char*, int line);
-void* debug_js_mallocz(JSContext*, size_t, const char*, int line);
-void* debug_js_realloc(JSContext*, void*, size_t, const char* file, int line);
-void* debug_js_realloc2(JSContext*, void*, size_t, size_t* pslack, const char* file, int line);
-void* debug_js_strdup(JSContext*, const char*, const char*, int line);
-void* debug_js_strndup(JSContext*, const char*, size_t, const char* file, int line);
-size_t debug_js_malloc_usable_size(JSContext*, const void*, const char*, int line);
-void debug_js_free(JSContext*, void*, const char*, int line);
-void* debug_js_malloc_rt(JSRuntime*, size_t, const char*, int line);
-void* debug_js_mallocz_rt(JSRuntime*, size_t, const char*, int line);
-void* debug_js_realloc_rt(JSRuntime*, void*, size_t, const char* file, int line);
-size_t debug_js_malloc_usable_size_rt(JSRuntime*, const void*, const char*, int line);
-void debug_js_free_rt(JSRuntime*, void*, const char*, int line);
-
-#if !defined(_IN_DEBUG_C)
-
-#if defined(DEBUG_ALLOC)
-#define malloc(size) debug_malloc(size, __FILE__, __LINE__)
-#define calloc(nelem, size) debug_calloc(nelem, size, __FILE__, __LINE__)
-#define realloc(ptr, size) debug_realloc(ptr, size, __FILE__, __LINE__)
-#define strdup(str) debug_strdup(str, __FILE__, __LINE__)
-#define free(ptr) debug_free(ptr, __FILE__, __LINE__)
-#define js_malloc(ctx, size) debug_js_malloc(ctx, size, __FILE__, __LINE__)
-#define js_mallocz(ctx, size) debug_js_mallocz(ctx, size, __FILE__, __LINE__)
-#define js_realloc(ctx, ptr, size) debug_js_realloc(ctx, ptr, size, __FILE__, __LINE__)
-#define js_strdup(ctx, str) debug_js_strdup(ctx, str, __FILE__, __LINE__)
-#define js_strndup(ctx, str, len) debug_js_strndup(ctx, str, len, __FILE__, __LINE__)
-#define js_free(ctx, ptr) debug_js_free(ctx, ptr, __FILE__, __LINE__)
-#define js_malloc_usable_size(ctx, ptr) debug_js_malloc_usable_size(ctx, ptr, __FILE__, __LINE__)
-#define js_malloc_rt(rt, size) debug_js_malloc_rt(rt, size, __FILE__, __LINE__)
-#define js_mallocz_rt(rt, size) debug_js_mallocz_rt(rt, size, __FILE__, __LINE__)
-#define js_realloc_rt(rt, ptr, size) debug_js_realloc_rt(rt, ptr, size, __FILE__, __LINE__)
-#define js_malloc_usable_size_rt(rt, ptr) debug_js_malloc_usable_size_rt(rt, ptr, __FILE__, __LINE__)
-#define js_free_rt(rt, ptr) debug_js_free_rt(rt, ptr, __FILE__, __LINE__)
-#endif
-
-#ifdef DEBUG_ALLOC
-#define realloc_helper(name) \
-  void* name(void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return debug_malloc(size, __FILE__, __LINE__); \
-    if(size == 0) \
-      return debug_free(ptr, __FILE__, __LINE__); \
-    return debug_realloc(ptr, size, __FILE__, __LINE__); \
-  }
-#define realloc2_helper(name) \
-  void* name(void* opaque, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return debug_malloc(size, __FILE__, __LINE__); \
-    if(size == 0) { \
-      debug_free(ptr, __FILE__, __LINE__); \
-      return 0; \
-    } \
-    return debug_realloc(ptr, size, __FILE__, __LINE__); \
-  }
-#define js_realloc_helper(name) \
-  void* name(JSContext* ctx, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return debug_js_malloc(ctx, size, __FILE__, __LINE__); \
-    if(size == 0) { \
-      debug_js_free(ctx, ptr, __FILE__, __LINE__); \
-      return 0; \
-    } \
-    return debug_js_realloc(ctx, ptr, size, __FILE__, __LINE__); \
-  }
-#define js_realloc_rt_helper(name) \
-  void* name(JSRuntime* rt, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return debug_js_malloc_rt(rt, size, __FILE__, __LINE__); \
-    if(size == 0) { \
-      debug_js_free_rt(rt, ptr, __FILE__, __LINE__); \
-      return 0; \
-    } \
-    return debug_js_realloc_rt(rt, ptr, size, __FILE__, __LINE__); \
-  }
-#else
-#define realloc_helper(name) \
-  void* name(void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return malloc(size); \
-    if(size == 0) { \
-      free(ptr); \
-      return 0; \
-    } \
-    return realloc(ptr, size); \
-  }
-#define realloc2_helper(name) \
-  void* name(void* opaque, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return malloc(size); \
-    if(size == 0) { \
-      free(ptr); \
-      return 0; \
-    } \
-    return realloc(ptr, size); \
-  }
-#define js_realloc_helper(name) \
-  void* name(JSContext* ctx, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return orig_js_malloc(ctx, size); \
-    if(size == 0) { \
-      orig_js_free(ctx, ptr); \
-      return 0; \
-    } \
-    return orig_js_realloc(ctx, ptr, size); \
-  }
-#define js_realloc_rt_helper(name) \
-  void* name(JSRuntime* rt, void* ptr, size_t size) { \
-    if(ptr == 0) \
-      return orig_js_malloc_rt(rt, size); \
-    if(size == 0) { \
-      orig_js_free_rt(rt, ptr); \
-      return 0; \
-    } \
-    return orig_js_realloc_rt(rt, ptr, size); \
-  }
-#endif
-#endif
-
-void* orig_malloc(size_t);
-void* orig_calloc(size_t, size_t);
-void* orig_realloc(void*, size_t);
-void* orig_strdup(const char*);
-void orig_free(void*);
-void* orig_js_malloc(JSContext*, size_t);
-void* orig_js_mallocz(JSContext*, size_t);
-void* orig_js_realloc(JSContext*, void*, size_t);
-void* orig_js_strdup(JSContext*, const char*);
-void* orig_js_strndup(JSContext*, const char*, size_t);
-size_t orig_js_malloc_usable_size(JSContext*, const void*);
-void orig_js_free(JSContext*, void*);
-void* orig_js_malloc_rt(JSRuntime*, size_t);
-void* orig_js_mallocz_rt(JSRuntime*, size_t);
-void* orig_js_realloc_rt(JSRuntime*, void*, size_t);
-size_t orig_js_malloc_usable_size_rt(JSRuntime*, const void*);
-void orig_js_free_rt(JSRuntime*, void*);
-
-/**
- * @}
- */
-#endif /* defined(DEBUG_H) */

src/quickjs/defines.h

@@ -1,181 +0,0 @@
-#ifndef DEFINES_H
-#define DEFINES_H
-
-/**
- * \defgroup defines defines: Preprocessor definitions
- * @{
- */
-
-#ifdef _WIN32
-#include <io.h>
-#define FD_TO_SOCKET(fd) ((SOCKET)_get_osfhandle((fd)))
-#define SOCKET_TO_FD(fh) (_open_osfhandle((intptr_t)(fh), O_RDWR | O_BINARY))
-#else
-#define FD_TO_SOCKET(fd) (fd)
-#define SOCKET_TO_FD(fh) (fh)
-#endif
-
-#ifndef offsetof
-#define offsetof(type, field) ((size_t) & ((type*)0)->field)
-#endif
-
-#ifndef inrange
-#define inrange(value, min, max) ((value) >= (min) && (value) <= (max))
-#endif
-
-#define trim_dotslash(str) (!strncmp((str), "./", 2) ? (str) + 2 : (str))
-
-#ifndef thread_local
-#ifdef _Thread_local
-#define thread_local _Thread_local
-#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
-#define thread_local __thread
-#elif defined(_WIN32)
-#define thread_local __declspec(thread)
-#else
-#error No TLS implementation found.
-#endif
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-#define PACK __attribute__((packed))
-#define ENDPACK
-#else
-#define PACK #pragma pack(push, 1)
-#define ENDPACK #pragma pack(pop)
-#endif
-
-#define JS_CGETSET_ENUMERABLE_DEF(prop_name, fgetter, fsetter, magic_num) \
-  { \
-    .name = prop_name, .prop_flags = JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE, .def_type = JS_DEF_CGETSET_MAGIC, .magic = magic_num, .u = { \
-      .getset = {.get = {.getter_magic = fgetter}, .set = {.setter_magic = fsetter}} \
-    } \
-  }
-
-#define JS_CGETSET_MAGIC_FLAGS_DEF(prop_name, fgetter, fsetter, magic_num, flags) \
-  { \
-    .name = prop_name, .prop_flags = flags, .def_type = JS_DEF_CGETSET_MAGIC, .magic = magic_num, .u = { \
-      .getset = {.get = {.getter_magic = fgetter}, .set = {.setter_magic = fsetter}} \
-    } \
-  }
-
-#define JS_CFUNC_DEF_FLAGS(prop_name, length, func1, flags) \
-  { \
-    .name = prop_name, .prop_flags = flags, .def_type = JS_DEF_CFUNC, .magic = 0, .u = {.func = {length, JS_CFUNC_generic, {.generic = func1}} } \
-  }
-
-#define JS_CONSTANT_FLAGS(name, flags) JS_PROP_INT32_DEF(#name, name, (flags))
-#define JS_CONSTANT(name) JS_PROP_INT32_DEF(#name, name, JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE)
-#define JS_CONSTANT_NONENUMERABLE(name) JS_PROP_INT32_DEF(#name, name, JS_PROP_CONFIGURABLE)
-
-#ifdef JS_SHARED_LIBRARY
-#if defined(_WIN32) || defined(__MINGW32__)
-#define VISIBLE __declspec(dllexport)
-#define HIDDEN
-#else
-#define VISIBLE __attribute__((visibility("default")))
-#define HIDDEN __attribute__((visibility("hidden")))
-#endif
-#else
-#define VISIBLE
-#define HIDDEN
-#endif
-
-#ifndef MAX_NUM
-#define MAX_NUM(a, b) ((a) > (b) ? (a) : (b))
-#endif
-#ifndef MIN_NUM
-#define MIN_NUM(a, b) ((a) < (b) ? (a) : (b))
-#endif
-#ifndef ABS_NUM
-#define ABS_NUM(n) ((n) < 0 ? -(n) : (n))
-#endif
-#ifndef MOD_NUM
-#define MOD_NUM(n, divisor) ((((n) % (divisor)) + (divisor)) % (divisor))
-#endif
-#ifndef SIGN_NUM
-#define SIGN_NUM(n) ((n) < 0)
-#endif
-
-#define COLOR_BLACK "\x1b[0;30m"
-#define COLOR_RED "\x1b[0;31m"
-#define COLOR_GREEN "\x1b[0;32m"
-#define COLOR_BROWN "\x1b[0;33m"
-#define COLOR_BLUE "\x1b[0;34m"
-#define COLOR_PURPLE "\x1b[0;35m"
-#define COLOR_MARINE "\x1b[0;36m"
-#define COLOR_LIGHTGRAY "\x1b[0;37m"
-#define COLOR_GRAY "\x1b[1;30m"
-#define COLOR_NONE "\x1b[0m"
-
-#define COLOR_LIGHTRED "\x1b[1;31m"
-
-#define COLOR_LIGHTGREEN "\x1b[1;32m"
-#define COLOR_YELLOW "\x1b[1;33m"
-#define COLOR_LIGHTBLUE "\x1b[1;34m"
-#define COLOR_MAGENTA "\x1b[1;35m"
-#define COLOR_CYAN "\x1b[1;36m"
-#define COLOR_WHITE "\x1b[1;37m"
-
-#define BGCOLOR_RED "\x1b[48;5;124m"
-#define BGCOLOR_BLUE "\x1b[48;5;20m"
-#define BGCOLOR_YELLOW "\x1b[48;5;214m"
-#define BGCOLOR_GREEN "\x1b[48;5;28m"
-#define BGCOLOR_PINK "\x1b[48;5;165m"
-
-#define JS_VALUE_FREE(ctx, value) \
-  do { \
-    JS_FreeValue((ctx), (value)); \
-    (value) = JS_UNDEFINED; \
-  } while(0);
-#define JS_VALUE_FREE_RT(ctx, value) \
-  do { \
-    JS_FreeValueRT((ctx), (value)); \
-    (value) = JS_UNDEFINED; \
-  } while(0);
-
-#if 0
-#define js_object_tmpmark_set(value) \
-  do { \
-    ((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] |= 0x40; \
-  } while(0);
-#define js_object_tmpmark_clear(value) \
-  do { \
-    ((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] &= ~0x40; \
-  } while(0);
-#define js_object_tmpmark_isset(value) (((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] & 0x40)
-#else
-#define js_object_tmpmark_set(value) \
-  do { \
-    JS_VALUE_GET_OBJ((value))->tmp_mark |= 0x40; \
-  } while(0);
-#define js_object_tmpmark_clear(value) \
-  do { \
-    JS_VALUE_GET_OBJ((value))->tmp_mark &= ~0x40; \
-  } while(0);
-#define js_object_tmpmark_isset(value) (JS_VALUE_GET_OBJ((value))->tmp_mark & 0x40)
-#endif
-
-#define js_runtime_exception_set(rt, value) \
-  do { \
-    *(JSValue*)((uint8_t*)(rt) + 216) = value; \
-  } while(0);
-#define js_runtime_exception_get(rt) (*(JSValue*)((uint8_t*)(rt) + 216))
-#define js_runtime_exception_clear(rt) \
-  do { \
-    if(!JS_IsNull(js_runtime_exception_get(rt))) \
-      JS_FreeValueRT((rt), js_runtime_exception_get(rt)); \
-    js_runtime_exception_set(rt, JS_NULL); \
-  } while(0)
-
-#define JS_ATOM_TAG_INT (1U << 31)
-#define JS_ATOM_MAX_INT (JS_ATOM_TAG_INT - 1)
-
-#define JS_ATOM_ISINT(i) ((JSAtom)((i)&JS_ATOM_TAG_INT))
-#define JS_ATOM_FROMINT(i) ((JSAtom)((i)&JS_ATOM_MAX_INT) | JS_ATOM_TAG_INT)
-#define JS_ATOM_TOINT(i) (unsigned int)(((JSAtom)(i) & (~(JS_ATOM_TAG_INT))))
-
-/**
- * @}
- */
-#endif /* defined(DEFINES_H) */

src/quickjs/hello.c

@@ -1,45 +0,0 @@
-/* File generated automatically by the QuickJS compiler. */
-
-#include "quickjs-libc.h"
-
-const uint32_t qjsc_hello_size = 87;
-
-const uint8_t qjsc_hello[87] = {
- 0x43, 0x04, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x6f,
- 0x6c, 0x65, 0x06, 0x6c, 0x6f, 0x67, 0x16, 0x48,
- 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72,
- 0x6c, 0x64, 0x22, 0x65, 0x78, 0x61, 0x6d, 0x70,
- 0x6c, 0x65, 0x73, 0x2f, 0x68, 0x65, 0x6c, 0x6c,
- 0x6f, 0x2e, 0x6a, 0x73, 0x0c, 0x00, 0x06, 0x00,
- 0xa2, 0x01, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00,
- 0x14, 0x01, 0xa4, 0x01, 0x00, 0x00, 0x00, 0x38,
- 0xe3, 0x00, 0x00, 0x00, 0x42, 0xe4, 0x00, 0x00,
- 0x00, 0x04, 0xe5, 0x00, 0x00, 0x00, 0x24, 0x01,
- 0x00, 0xcf, 0x28, 0xcc, 0x03, 0x01, 0x00,
-};
-
-static JSContext *JS_NewCustomContext(JSRuntime *rt)
-{
-  JSContext *ctx = JS_NewContextRaw(rt);
-  if (!ctx)
-    return NULL;
-  JS_AddIntrinsicBaseObjects(ctx);
-  return ctx;
-}
-
-int main(int argc, char **argv)
-{
-  JSRuntime *rt;
-  JSContext *ctx;
-  rt = JS_NewRuntime();
-  js_std_set_worker_new_context_func(JS_NewCustomContext);
-  js_std_init_handlers(rt);
-  ctx = JS_NewCustomContext(rt);
-  js_std_add_helpers(ctx, argc, argv);
-  js_std_eval_binary(ctx, qjsc_hello, qjsc_hello_size, 0);
-  js_std_loop(ctx);
-  js_std_free_handlers(rt);
-  JS_FreeContext(ctx);
-  JS_FreeRuntime(rt);
-  return 0;
-}

src/quickjs/iso_8859_1.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_1_H
-#define TUTF8E_ISO_8859_1_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_1_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_1, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_1_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_1, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_1_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_1, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_1_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_1, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_10.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_10_H
-#define TUTF8E_ISO_8859_10_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_10_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_10, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_10_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_10, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_10_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_10, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_10_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_10, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_11.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_11_H
-#define TUTF8E_ISO_8859_11_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_11_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_11, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_11_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_11, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_11_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_11, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_11_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_11, input, input_length, invalid, output, output_length);
-}
-
-#endif

src/quickjs/iso_8859_13.h

@@ -1,27 +0,0 @@
-
-#ifndef TUTF8E_ISO_8859_13_H
-#define TUTF8E_ISO_8859_13_H
-
-#include <tutf8e.h>
-
-static inline int tutf8e_iso_8859_13_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_13, input, input_length, invalid, output_length);
-}
-
-static inline int tutf8e_iso_8859_13_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
-{
-  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_13, input, invalid, output, output_length);
-}
-
-static inline int tutf8e_iso_8859_13_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
-{
-  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_13, input, input_length, invalid, length);
-}
-
-static inline int tutf8e_iso_8859_13_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
-{
-  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_13, input, input_length, invalid, output, output_length);
-}
-
-#endif