check_amendment_blocked

Decode an executehook trace[] into human-readable values by byte-width: canonical XFL float (definite), int64/native-drops (both endians), UInt32 + Ripple-epoch date, candidate account-id → r-address (possible), 32-byte hash. Raw hex always preserved; offline.

Pull every hook on an account and analyze all of them.

Infer in plain English what a hook does (firewall/emitter/stateful/financial/…).

Project claimable XAH network reward (DOCUMENTEDMODEL; legacy — prefer rewardstatus).

Decode native drops / 8-byte / 48-byte issued STAmount / amount object → value+currency+issuer.

Burn2Mint classification.

Decode an Evernode lease URIToken (evrlease/LTV) → lease index, EVR amount (XFL), ToS hash, IP.

Engine result code ⇄ name (e.g. 153 ⇄ tecHOOKREJECTED).

A SetHook tx → its hook definitions, HookOn decoded.

Decode a Xaman txjson or txblob → plain-English "what you authorize" + safety warnings.

Decode an Import/Burn2Mint XPOP → source ledger, inner burn tx, burned drops, UNL validators.

"Why did my transaction fail?" — plain-English diagnosis from on-chain facts: engine result → cause + concrete fix (~30-code catalog), hook rollback return-strings decoded and interpreted (the reward hook's "You must wait N seconds" becomes a claimable-at date), the partial-payment trap on "successf

Diff enabled-amendment sets across two networks (e.g. mainnet vs testnet) — explains why a tx/Hook feature works on one but not the other.

Byte size (SetHook fee) + static instruction count (complexity proxy), ESTIMATE.

ExtendedHookState reserve math: value bytes + scale (1–16) → per-entry capacity (256×scale), reserve units (= scale), totals, overflow + min-scale warnings, optional XAH.

One-call Evernode host health check (the official troubleshooting checklist, automated): registration entry, heartbeat liveness vs the on-chain active rule, instance load, reputation, EVR trustline/balance, registration URIToken, lease offers, machine specs + accumulated EVR reward. Layout verified

Run the real Hook bytecode in a local VM against a simulated tx/state → actual accept/rollback, return code, state writes, emits, trace (LOCALVM).

One-call plain-English account snapshot — balance, key safety, hooks, trustlines, Evernode leases, recent activity (5 serial reads).

Differential fuzzing: sweep many generated transactions through the VM to map the hook's accept/rollback decision boundary (which tx types / amounts it accepts vs rejects).

Every enabled amendment (resolved to its human name where known, raw hash otherwise) + any in the voting set (already >80%, counting toward enablement). Reads the on-ledger Amendments singleton — no admin feature call needed.

Full live decode of the Governance Game: all 20 seats + members, member count, live reward rate/delay, every open vote (who voted what) and every tally with its threshold (80% membership / 100% else) and reached-flag. Layout canonical from xahaud hook/genesis/govern.c.

Compare two hook versions — API/HookOn/size deltas + newly-gained sensitive capabilities.

STATICONLY quick check — fires-on-tx + exit calls present (use executehook for real runs).

Post-mortem a real on-chain tx's hooks: fetch the tx + its meta.HookExecutions + engine result, then run each fired hook's real bytecode through the VM and compare the VM's accept/rollback to what the chain recorded. On-chain decision is authoritative; VM run is LOCALVM; agree is null (not false) wh

One-call full report: structure + plain-English classification + security findings + fee.

Decode a hook's emit() blobs → tx JSON + plain-English summary + danger score.

Parse CreateCode WASM: imports, exports (hook/cbak), memory, custom sections, loop, g guard & instruction counts.

For each amendment holding majority: when it reached >80% and its estimated enable time (majority + Xahau's 5-day window), with days remaining and an eligible-now flag.

Grade an account for quantum (HNDL) readiness — master-key/regular-key/multisig + hooks → score, tier, recommendations (with a Hook/PQC angle).

Balance Adjustment doctor — opted in? exact accrued XAH (the genesis reward hook's own formula from reward.c, with live RR/RD read from genesis hook state; reproduces a real on-chain GenesisMint payout to the drop), next-claim countdown, overdue-claim warning (late claiming forfeits yield), plus an

Generate a starter Hook in C for an intent (firewall/payment-limit/state-counter/…) — then verify with analyze/execute.

Score a sign request (txjson or txblob) for risky patterns → dangerScore 0-100 + SAFE/CAUTION/DANGER tier + per-rule findings (SetHook, AccountDelete-to-other, regular-key/signer-list changes, large native payment, no-expiry, pre-signed). Offline heuristic on tx shape only — every finding is a poten

Static (no-RPC, no-bytecode) prediction of which accounts' hooks a tx would invoke, strong (can rollback) vs weak. Complements simulatetransaction.

PRE-SIGN FLIGHT SIMULATOR — predict an unsigned tx's fate: originator + stakeholder hook chains (order canonical from xahaud Transactor.cpp/applyHook.cpp) run as real bytecode against live state; per-hook verdicts, decoded emits, state writes, static engine preflights, scam score.

Every account a tx touched, from metadata. The Touch amendment forces all stakeholders into metadata, so this is the authoritative participant list (roles + entry types + materially-changed flag).

Structural audit of a tx's metadata threading; flags the duplicate-node symptom fixProvisionalDoubleThreading addressed.

Honest fidelity metric: replays a committed corpus of real mainnet HookExecutions through the VM and reports agreement % over comparable (non-degraded) runs only; offline.

TIME MACHINE — fetch a real historical tx, apply your overrides, re-simulate at its original ledger. Reproduces the real reward claim's GenesisMint to the drop (test-locked).