xahau-mcp
xahau-mcp is a read-only Xahau MCP server for locally executing/auditing Hooks, simulating transactions, decoding Xahau data, reading ledger state, and building unsigned transactions.
Run Hook bytecode locally:
execute_hookruns real CreateCode WASM in a local VM and reports accept/rollback, return codes, state writes, emitted txns, and trace; noxahaudnode needed.Simulate before signing:
simulate_transactionpredicts unsigned-tx hook outcomes against live state;what_ifreplays historical txns with overrides;fuzz_hookmaps accept/rollback decision boundaries.Analyze/audit Hooks:
analyze_hook,hook_report,audit_account_hooks,inspect_hook_wasm,classify_hook,hook_diff,scaffold_hook,list_rules,hook_api_lookup,hook_dry_run,estimate_hook_fee.Verify VM fidelity/post-mortem:
vm_fidelity_reportcompares the local VM to real mainnet HookExecutions;hook_execution_postmortemreplays on-chain hooks.Read ledger: server info, accounts, account objects/hooks/lines/offers/URITokens, hook definitions/state, transactions, ledgers, and fees.
Decode/codec: HookOn/HookCanEmit, SetHook/tx blobs, URIToken IDs, amounts, XPOP, emitted txns, Evernode lease URIs, sign requests, scam checks, addresses/X-addresses, currency, Ripple time, and result codes.
Economics/governance:
reward_status,compute_reward,governance_state, Evernode host diagnostics,decode_b2m, and amendment status/prediction/blocked/diff tools.Audit/forensics:
trace_transaction_stakeholders,verify_double_threading,audit_account_remarks, anddiagnose_failed_tx.Build unsigned transactions: SetHook, ClaimReward, Import, Payment, Remit, SetRemarks, Clawback, DeepFreeze, CronSet, regular key, signer list, disable master, and
prepare_transaction; never signs, testnet-default.Quantum/HNDL:
quantum_grade,quantum_config_census,quantum_scorecard,hndl_exposure,master_pubkey, anddisable_master_readiness.Cron:
build_cronset_unsigned,list_cron_jobs, andmonitor_cron_health.MCP extras: resources and prompts for Hook audit/simulation workflows, per README.
Provides tools for interacting with the Xahau network (a fork of the XRP Ledger), including running Hook WebAssembly bytecode, static analysis of Hooks, decoding transactions and ledger state, building unsigned transactions, and analyzing governance and economics.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@xahau-mcp run hook_report on the hook with hash abc123"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
xahau-mcp
A Model Context Protocol server for the Xahau network with two firsts: it runs a Hook's real WebAssembly bytecode in a local VM (no xahaud node required), and it runs a Hooks-specific static-analysis / security rule engine over it — both fully offline. Around that core it adds read-only ledger access, a Xahau-aware binary codec, an instruction-count fee estimate, network-reward math, governance helpers, and unsigned-transaction builders.
Xahau is the XRPL fork whose flagship feature is Hooks — small on-ledger WebAssembly smart contracts. There was no MCP for Xahau and no static analyzer for Hooks; this is both.

The trifecta — safe Hooks, end to end
Three open-source tools, one workflow: write → simulate one tx → prove all inputs. xahau-mcp is the simulate stage.
stage | tool | what it does |
write | author + compile a safe Hook to clean, lint-passed WASM | |
simulate one | run the real bytecode against one live transaction | |
prove all | prove an invariant holds for every input in scope — or return the counterexample |
Related MCP server: StellarMCP
Why it's useful
Point any MCP-capable agent (Claude, etc.) at this server and it can:
See the future before signing —
simulate_transactionis a pre-sign flight simulator: every hook an unsigned transaction would trigger runs as real bytecode against live ledger state, with per-hook accept/rollback, decoded emitted transactions, simulated state writes and labeled static engine preflights. Its siblingwhat_ifis a time machine: replay any real historical transaction — with your modifications — at its original ledger. Verified to reproduce a real claim's emittedGenesisMintpayout to the drop (72,251,963 drops), test-locked.Run a Hook without deploying it —
execute_hookinstantiates the real CreateCode WASM in a local VM, supplies the Hook API over a simulated transaction + ledger state, and reports the actualaccept/rollbackdecision, return code/string, state writes, emitted transactions and a call trace. Noxahaudnode needed.Audit a Hook before it's installed — paste the CreateCode WASM (or an on-ledger hook hash) and get SARIF-lite findings: missing
accept/rollbackexit, unguarded loops (_g), unknownenvimports, dangerousHookGrants, over-broadHookOn, and more.Decode the cryptic
HookOnbitmap in both directions — the 256-bit, inverted, active-low mask (with the active-high SetHook bit) is easy to get wrong; here it's verified and round-trip-tested.Read Xahau ledger state — accounts, installed hooks, hook definitions, hook state, transactions (with
HookExecutionsmetadata), ledgers.Answer the #1 retail question —
reward_statustells any account whether it's opted in to Xahau network rewards (Balance Adjustments), the exact XAH accrued — computed with the genesis reward hook's own formula and live parameters, verified to reproduce a real on-chain payout to the drop — when it can next claim, and whether the claim is overdue (late claiming forfeits yield).Diagnose an Evernode host —
evernode_host_diagnosticsautomates the official troubleshooting checklist for Xahau's largest operator group: registration, heartbeat liveness (the actual on-chain active rule), reputation, EVR trustline, lease offers, specs and accumulated rewards, in one read-only call.Explain a failed transaction —
diagnose_failed_txturns an engine result + hook return strings into a plain-English cause and a concrete fix.Watch governance live —
governance_statedecodes the Genesis Governance Game's full hook state: who holds the 20 seats, every open vote and tally, and whether a change (member swap, reward-rate change) is about to be actioned. No explorer shows this.Build unsigned transactions (SetHook, ClaimReward, Payment) with an automatic security preflight — returned unsigned, to be signed offline.
Why this is the most advanced blockchain MCP we know of
Strong claim, so here is the checkable evidence (2026-06-11). To our knowledge no MCP for ANY chain — Ethereum, Solana, Bitcoin, XRPL or otherwise — combines even two of these; the closest comparators are cloud-simulation MCPs (e.g. Tenderly's, which simulates on their hosted infrastructure) and standalone analyzers (e.g. Slither, which is EVM-only and not an MCP):
Executes real on-chain contract bytecode in a LOCAL VM —
execute_hookruns the actual CreateCode WASM with no node, no cloud, no account. Not an ABI wrapper, not a hosted simulator.Publishes a measured, regression-locked fidelity score against chain ground truth —
vm_fidelity_reportreplays 30 real mainnet hook executions: 30/30 agree (100%), 0 degraded, including the foreign-state-reading hook that dominates live traffic. Those 30 are all accept-direction (live Xahau traffic is heartbeat-dominated), and the metric says so itself — it reports the accept/rollback composition and warns that an accept-only corpus can't distinguish the VM from an always-accept stub. The rollback direction is exercised on real genesis bytecode (governanceInvoke→ rollback) intests/regression.test.ts. The corpus, the method and the honest history (25% → 0% → 100%) are in docs/FIDELITY.md. We know of no other blockchain MCP that even attempts this.In-protocol static security analysis — a Hooks-specific rule engine (SARIF-lite findings), calibrated against the network's own genesis hooks.
In-protocol differential fuzzing —
fuzz_hookmaps a contract's accept/reject decision boundary in the local VM.Post-mortems real transactions with real bytecode —
hook_execution_postmortemreplays what actually fired on chain and compares.Reproduces on-chain economics exactly —
reward_statusre-implements the genesis reward hook's formula and reproduces a real emitted payout to the drop (verified, test-locked).Decodes live governance end-to-end —
governance_stateshows every seat, vote, tally and threshold of the Governance Game, live.Operational doctors for the ecosystem's real pain: failed-tx diagnosis with cause+fix, Evernode host health, claim-overdue detection.
Every claim above is reproducible from this repo: the corpus is committed, the tests assert the numbers, and the canonical sources (xahaud genesis hooks, evernode-js-client) are cited in code.
Safety posture
Read-only toward the network. There is no
submitand nosignanywhere in this server.No key custody. Builder tools never accept a secret/seed and always return an unsigned transaction plus instructions to sign offline (e.g. with xaman or
xrpl-accountlib). They default to testnet.Honest fidelity.
execute_hookruns the real bytecode against a simulated environment. The VM implements a large slice of the 78-function Hook API — nearly the whole XFL float API (verified againstfloat_one;float_root/float_logare the exceptions — they returnNOT_IMPLEMENTED), the slot table + STObject subfield extraction (slot_subfield/sto_subfield, byte-exact against real txns), state,otxn_*/hook_*,util_accid/util_raddr/util_verify/util_sha512h, and more. STObject mutation (sto_emplace/erase/validate),util_keylet(account + hook verified against live ledger indexes; offer/escrow/check/ticket/signers canonical + fail-safe),slot_set+ foreign hook state (state_foreign/state_foreign_set) with async pre-resolve (execute_hook resolveKeylets:truefetches the ledger objects AND foreign-state entries the hook reads — iteratively, since one resolved read can expose the next — and re-runs),slot_float/float_sto/float_sto_set(STAmount ⇄ XFL both ways — parse a native or issued/IOU Amount into a float and serialize one back; the issued layout below bit 63 is the XFL layout), and 32-byte state-key padding (short keys are left-zero-padded exactly as on-ledger) are now supported.state_foreign_setrecords the write but does NOT model the on-chain HookGrant requirement;etxn_detailsserves a disclosed SYNTHETIC placeholder (listed insyntheticCalls, cannot change the accept/rollback decision). What still can't be faithful is honestly recorded: unverified keylet subtypes,meta_slot, and other un-modelled calls return the realNOT_IMPLEMENTEDcode, are listed inunsupportedCalls, and mark the rundegraded— never faked. The VM models the guard budget (_genforces each guard's declaredmaxiter→GUARD_VIOLATION), and reportsstateApplied(state writes commit only onaccept, discarded onrollback). It is not a consensus-faithfulxahaudreplica — it has no fee/fuel metering beyond guards, XFL math truncates rather than round-half-up (sofloat_mulratio's round-up flag and last-significant-digit results can differ), value-level math is verified only where tested. Hooks with a loop but no_gguard are refused before execution (invalid on-chain), and guarded runs are bounded by a VM budget (1M cumulative guard calls / 2s wall clock — labeled as a local VM cap, not a consensus limit); always confirm financial/resource hooks on testnet.hook_dry_runisSTATIC_ONLY,compute_rewardisDOCUMENTED_MODEL(legacy — preferreward_status, whoseREWARD_HOOK_FORMULAre-implementsreward.cexactly and reproduces a real on-chainGenesisMintpayout to the drop),estimate_hook_feeisESTIMATE.Resources & prompts. Beyond tools, the server exposes MCP resources (
xahau://rules,xahau://hook-api,xahau://tx-types) and guided prompts (audit_hook,simulate_hook,explain_hook) so agents can pull reference data and run the common workflows directly.
Tools
Hook intelligence (offline — the core)
Tool | Purpose |
| Run the real Hook bytecode in a local VM against a simulated tx/state → actual accept/rollback, return code, state writes, emits, trace ( |
| PRE-SIGN FLIGHT SIMULATOR — predict an unsigned tx's fate: originator + stakeholder hook chains (order canonical from xahaud |
| TIME MACHINE — fetch a real historical tx, apply your overrides, re-simulate at its original ledger. Reproduces the real reward claim's |
| 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). |
| Decode an |
| One-call full report: structure + plain-English classification + security findings + fee. |
| Post-mortem a real on-chain tx's hooks: fetch the tx + its |
| Honest fidelity metric: replays a committed corpus of real mainnet HookExecutions through the VM and reports agreement % over comparable (non-degraded) runs only; offline. |
| Infer in plain English what a hook does (firewall/emitter/stateful/financial/…). |
| Compare two hook versions — API/HookOn/size deltas + newly-gained sensitive capabilities. |
| Generate a starter Hook in C for an intent (firewall/payment-limit/state-counter/…) — then verify with analyze/execute. |
| Run the static-analysis rule engine over a hook → SARIF-lite findings. |
| Pull every hook on an account and analyze all of them. |
| Parse CreateCode WASM: imports, exports ( |
| Byte size (SetHook fee) + static instruction count (complexity proxy), |
|
|
| Enumerate analyzer rules · look up a Hook API function's role & hazards. |
Codec / decode (offline)
Tool | Purpose |
| HookOn bitmap ⇄ transaction-type list. |
| HookCanEmit bitmap ⇄ the tx types a hook may emit (HookCanEmit amendment; absent = may emit anything). |
| ExtendedHookState reserve math: value bytes + scale (1–16) → per-entry capacity (256×scale), reserve units (= scale), totals, overflow + min-scale warnings, optional XAH. |
| Static (no-RPC, no-bytecode) prediction of which accounts' hooks a tx would invoke, strong (can rollback) vs weak. Complements |
| A SetHook tx → its hook definitions, HookOn decoded. |
| Xahau tx blob ⇄ JSON (unsigned). |
| URIToken ID validation · XAH⇄drops. |
| Decode an Import/Burn2Mint XPOP → source ledger, inner burn tx, burned drops, UNL validators. |
| Engine result code ⇄ name (e.g. 153 ⇄ tecHOOK_REJECTED). |
| "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 "successful" Payments, and not-found triage (expired |
| Validate classic/X-address (type, account-id, tag) · encode/decode X-addresses. |
| 3-char ISO ⇄ 160-bit currency · Ripple-time ⇄ Unix/ISO. |
| Decode native drops / 8-byte / 48-byte issued STAmount / amount object → value+currency+issuer. |
| Decode a Xaman txjson or tx_blob → plain-English "what you authorize" + safety warnings. |
| Decode an Evernode lease URIToken ( |
| 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 against the canonical |
| Decode a hook's |
| Score a sign request (txjson or tx_blob) for risky patterns → |
Ledger (read-only RPC)
Tool | Purpose |
| Node/account reads. |
| Hook reads. |
| Tx (with |
| Trustlines · DEX offers · URITokens (NFTs, URI decoded). |
| One-call plain-English account snapshot — balance, key safety, hooks, trustlines, Evernode leases, recent activity (5 serial reads). |
Economics / governance
Tool | Purpose |
| Balance Adjustment doctor — opted in? exact accrued XAH (the genesis reward hook's own formula from |
| Project claimable XAH network reward ( |
| Grade an account for quantum (HNDL) readiness — master-key/regular-key/multisig + hooks → score, tier, recommendations (with a Hook/PQC angle). |
| 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 |
| Burn2Mint classification. |
Amendment intelligence (read-only, no admin node)
Tool | Purpose |
| 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 |
| 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. |
| Is the configured node amendment blocked (xahaud too old to read an enabled amendment)? Build version, validated ledger, upgrade remedy. |
| 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. |
Audit / forensics
Tool | Purpose |
| 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 |
| Decode the Remarks attached to an account's objects (name/value hex→text, immutable flag) — dynamic-NFT and annotation patterns. |
Unsigned builders (no keys, testnet-default)
Tool | Purpose |
| UNSIGNED SetHook with automatic |
| UNSIGNED ClaimReward · Import/B2M · Payment. |
| UNSIGNED Remit (XLS-55) — atomic multi-asset push: multiple currencies (native + issued) and/or URIToken transfers and/or an inline URIToken mint to one destination, all-or-nothing. Canonical |
| UNSIGNED SetRemarks (Remarks amendment) — attach/update/delete key-value remarks on a ledger object you own/issue. |
| UNSIGNED Clawback — issuer revokes issued tokens from a holder ( |
| UNSIGNED TrustSet freeze toggle — |
| Autofill Sequence/Fee/LastLedgerSequence/NetworkID from the live network → ready to sign offline (never signs). |
Cron (scheduled Hook execution)
Tool | Purpose |
| UNSIGNED CronSet — schedule a Hook's future self-invocations: |
| Read an account's Cron ledger objects with decoded StartTime (ISO), DelaySeconds, remaining RepeatCount, and an estimated next-fire time (raw object included). |
| Flag Crons whose remaining repeats are near exhaustion (≤ threshold) so a recurring governance/game Hook doesn't silently stop. |
Install
New here or non-technical? Start with the plain-English tutorial — what it does + cool things to just ask.
Requires Node.js 20+. The server speaks MCP over stdio; your MCP client launches it.
From npm
npx -y xahau-mcp --help # run without installing (prints usage and exits)
npm install -g xahau-mcp # or install the `xahau-mcp` command globally
xahau-mcp --smoke # health check: local data + one live mainnet readRun with no arguments, xahau-mcp waits for an MCP client on stdin/stdout — it is not an interactive CLI.
Add it to an MCP client
Claude Code:
claude mcp add xahau -- npx -y xahau-mcpClaude Desktop (claude_desktop_config.json), or any client that takes an mcpServers block:
{
"mcpServers": {
"xahau": { "command": "npx", "args": ["-y", "xahau-mcp"] }
}
}If you installed globally, "command": "xahau-mcp" with no args works too. To pin your own RPC nodes, add "env": { "XAHAU_RPC_URLS": "https://your-node.example" } (comma-separated; XAHAU_TEST_RPC_URLS for testnet).
The server is read-only toward the network: it reads ledger state over public JSON-RPC, never signs or submits a transaction, and holds no keys. The offline tools (Hook VM, static analyzer, codec, HookOn) need no network at all.
From GitHub / source
npm install -g github:Hugegreencandle/xahau-mcp # builds on install via `prepare`Or clone and build:
git clone https://github.com/Hugegreencandle/xahau-mcp && cd xahau-mcp
npm install # the `prepare` script compiles dist/ automatically
npm run smoke # health check + a live mainnet read
npm test # offline test suiteOlder versions (≤ 1.4.0) were published to GitHub Packages as @hugegreencandle/xahau-mcp; that scope needs a GitHub token even for public installs. Use the unscoped npm package above instead.
HTTP shim (browsers, wallets, web tools)
The MCP server speaks stdio — browsers, the Xaman webview, and a public "simulate any hook" web tool can't. The HTTP shim (src/http.ts) exposes the same flight-simulator core over plain HTTP. Read-only; never signs or submits.
PORT=8787 npm run http # or: PORT=8787 node dist/http.js
curl localhost:8787/health
# or deploy the container (non-root, healthchecked):
docker build --target http -t xahau-mcp-http .
docker run -p 8787:8787 -e MAX_INFLIGHT=2 -e XAHC_HOOK_MEM_MB=128 xahau-mcp-httpOn platforms that build the last Dockerfile stage (Railway, etc.), use Dockerfile.http (set RAILWAY_DOCKERFILE_PATH=Dockerfile.http) — it's the http stage as the final stage.
Endpoints
Method · path | Body | Returns |
|
| full |
|
|
|
|
|
|
|
|
|
| — | the VM fidelity report + |
| — |
|
Simulate a not-yet-deployed hook — pass candidateCode (the built wasm hex) on /simulate. It replaces tx.Account's on-ledger hook chain, so a freshly-compiled hook runs against the live ledger + full TSH chain BEFORE you SetHook it. (This is what xahc verify and a public simulate tool call.)
Config (env)
Var | Default | Purpose |
|
| listen port |
|
| requests / IP / minute |
|
| concurrent simulations |
|
| hard wall-clock per hook execution |
|
| memory cap per hook execution |
| sim default | inter-read RPC spacing — |
| unset | set only when behind a reverse proxy that sets |
|
| comma-separated mainnet RPC failover list |
Running it publicly
The shim serves untrusted, user-supplied wasm, so each hook execution runs in a throwaway worker_thread with the timeout + memory cap above — a hanging or allocation-bombing hook is terminated without blocking or crashing the main process (security-audited; an infinite loop / unguarded recursion returns 422, not downtime). For a public deploy:
Run behind a process supervisor (systemd / pm2 / container restart policy) for defense-in-depth.
Only set
TRUST_PROXYwhen genuinely behind a proxy that setsX-Forwarded-For; otherwise the rate limiter keys on the socket address (setting it lets clients spoof the header and bypass the limit).Per-IP rate limit + a global concurrency cap are on by default — tune via env.
Security
Designed defensively and reviewed (npm audit + a danger-surface pass):
Read-only & no key custody — no
sign/submitanywhere; builder tools never accept a secret and only emit unsigned transactions to sign offline.No code-exec surface — no
eval/Function, nochild_process/shell, no filesystem writes, no dynamicrequire. RPCfetchonly ever hits the fixed endpoints indata/endpoints.json(or yourXAHAU_RPC_URLS/XAHAU_TEST_RPC_URLSoverrides for mainnet/testnet) — never a URL built from tool input, so no SSRF.Untrusted Hook WASM is sandboxed —
execute_hook/fuzz_hookrun hook bytecode in Node's WebAssembly engine, which has no syscall/fs/network access; a hook can only call the in-memory JS Hook-API shims, with bounds-checked memory reads/writes.Untrusted-bytecode hardening: before executing a hook the VM refuses modules with an unguarded loop (more loops than
_gguard call-sites), with an opcode-scan that couldn't verify the loops, over 128 KiB of bytecode, or declaring more than 512 memory pages; guarded loops are bounded by a cumulative guard budget + wall-clock cap. So an attacker-supplied hook can't hang or OOM a run. Tool output is data, not instructions (treat it as such, as with any MCP).Dependencies:
npm auditreports only low-severity advisories transitively underxrpl-accountlib's signing libraries (elliptic/bip32/tiny-secp256k1) — code paths this server never calls (it uses only the binary codec).
How it works
No heavy deps. Three runtime deps:
@modelcontextprotocol/sdk,zod, andxrpl-accountlib(used only for the Xahau-aware binary codec; its signing surface is never called). RPC is plainfetch; the WASM reader is hand-rolled and zero-dep; the VM uses Node's built-inWebAssemblyengine to run the bytecode with a JS Hook API shim — no WASM toolchain or native deps.Real data, regenerable.
data/is built from a live Xahau node'sserver_definitionsand the canonical Hook API list (Xahau/hooks-rsc/extern.h) vianpm run fetch:all. The 78-function Hook API catalog carries per-function hazard metadata that drives the analyzer.HookOn semantics are verified against the Xahau docs: 256-bit, bit n = tx type n, inverted/active-low (set = does not fire), with bit 22 (SetHook) active-high.
License
MIT © 2026 Dane Brown. Not affiliated with XRPL Labs or the Xahau project. Analyzer findings are heuristic guidance, not a security guarantee — always test on testnet and review hooks independently before mainnet use.
Available Tools
87 toolsanalyze_hookB
THE MOAT: run the Hook static-analysis / security rule engine over a CreateCode WASM (+ optional SetHook params) and return SARIF-lite findings. The first Hooks-specific analyzer. Offline.
Inputs: flags, grants, hookOn, wasmHex, +3 more. Returns: error, valid, decoded, summary, +1 more
annotate_hook_traceA
Annotate the trace[] array from an execute_hook result. Each entry is "label: HEXVALUE" (the hook's trace() memory dump). Decodes each blob by byte-width: 8-byte → canonical XFL float (definite) else int64 (both endians) + native-drops reading; 4-byte → UInt32 (both endians) + Ripple-epoch ISO date if in range; 20-byte → candidate account-id → r-address (possible, since arbitrary bytes can coincidentally encode); 32-byte → possible tx/hook hash (heuristic); other widths → raw blob. The raw hex is ALWAYS preserved as the primary field; nothing is suppressed; confidence is 'definite' only for canonical XFL. Fully offline, no network.
Inputs: trace (required).
audit_account_hooksB
Fetch every hook on an account, pull each HookDefinition's WASM, and run the analyzer over all of them. Read-only network + offline analysis.
Inputs: address (required), network.
audit_account_remarksA
Read the Remarks (Remarks amendment) attached to an account's owned ledger objects — decoded name/value (hex→text where printable) with the immutable flag surfaced. Useful for dynamic-NFT patterns and object annotations. Follows the account_objects marker so accounts with many objects don't drop remarks on later pages (capped at 20 pages — truncated:true if hit); 1+ RPC reads.
Inputs: account (required), network. Returns: note, error, account, network, +8 more
build_claimreward_unsignedA
Assemble an UNSIGNED ClaimReward transaction. Returns unsigned JSON + offline signing instructions. Never signs; testnet by default.
Inputs: account (required), issuer, network.
build_clawback_unsignedA
Assemble an UNSIGNED Clawback — an issuer revokes previously-issued tokens from a holder (ported from XRPL). Account is the ISSUER; the holder is whom you claw from. NOTE: requires the issuer to have enabled clawback (AccountSet asfAllowTrustLineClawback) BEFORE issuing. Cannot claw native XAH. Returns unsigned JSON + preflight. Never signs; testnet by default.
Inputs: value (required), holder (required), account (required), currency (required), +1 more.
build_cronset_unsignedA
Assemble an UNSIGNED CronSet — schedule a Hook's future self-invocations (Cron amendment). StartTime is Ripple-epoch seconds (0/omitted = ASAP); use startInSeconds for now+N. RepeatCount 0–256 (omit for a one-off), DelaySeconds = interval between repeats. Set cancel:true for tfCronUnset to remove the Cron. The account must have a Hook installed to act on the Cron pseudo-transaction. Returns unsigned JSON + preflight. Never signs; testnet by default.
Inputs: account (required), cancel, network, startTime, +3 more.
build_deepfreeze_unsignedA
Assemble an UNSIGNED TrustSet that toggles a freeze on your trustline to a counterparty. action: deep_freeze (blocks holder sending AND receiving — needs DeepFreeze amendment), clear_deep_freeze, freeze (blocks sending only), unfreeze. Returns unsigned JSON + preflight. Never signs; testnet by default.
Inputs: account (required), currency (required), counterparty (required), action, +2 more.
build_disable_master_unsignedA
ROTATION WIZARD step 3 — assemble an UNSIGNED AccountSet asfDisableMaster (retire the master key). IRREVERSIBLE. ALWAYS runs disable_master_readiness internally and FAILS CLOSED — blocked=true unless a PROVEN working alternative signer exists (a regular key that has signed, or a reachable signer list that has multi-signed). Never signs.
Inputs: account (required), network.
build_import_unsignedA
Assemble an UNSIGNED Import (Burn2Mint) transaction wrapping a HEX-encoded XPOP in the Blob field. Returns unsigned JSON + offline signing instructions. Never signs; testnet by default.
Inputs: account (required), xpopBlobHex (required), network.
build_payment_unsignedA
Assemble an UNSIGNED XAH Payment (amount in drops). Returns unsigned JSON + offline signing instructions + payload preflight. Never signs; testnet by default.
Inputs: account (required), amountDrops (required), destination (required), network, +1 more.
build_remit_unsignedA
Assemble an UNSIGNED Remit (XLS-55) — Xahau's atomic multi-asset push payment. Send multiple currencies (native + issued) and/or transfer existing URITokens and/or mint a new URIToken to one Destination in a single all-or-nothing transaction. The transactor auto-creates missing trustlines, pays token reserves, and creates the destination account if absent (no partial payments, no pathing). Optionally Inform a third-party hook. Returns unsigned JSON + payload preflight + offline signing instructions. Never signs; testnet by default.
Inputs: account (required), destination (required), blob, inform, +6 more.
build_sethook_unsignedA
Assemble an UNSIGNED SetHook transaction from CreateCode + params, auto-running analyze_hook as preflight and flagging CRITICAL findings. Returns unsigned JSON + offline signing instructions. Never signs; testnet by default.
Inputs: account (required), namespace (required), flags, grants, +6 more.
build_set_regular_key_unsignedA
ROTATION WIZARD step 1 — assemble an UNSIGNED SetRegularKey to assign a rotatable regular key (or remove it if regularKey omitted). Moving authority off the unrotatable master key is the near-term quantum (HNDL) defense. Returns unsigned JSON + signing instructions; NEVER touches a secret. After it lands, send a TEST tx signed by the new key before disabling master.
Inputs: account (required), network, regularKey.
build_set_remarks_unsignedA
Assemble an UNSIGNED SetRemarks (Remarks amendment) — attach, update, or delete key-value remarks on a ledger object you own (or, for URITokens/trustlines, issue). Each remark: name (required), value (omit to DELETE), immutable (Flags:1 = permanent). Max 32 per object, names unique, 1–256 bytes each; cost +1 drop/byte. RemarkName/RemarkValue are hex (non-hex text is UTF-8 encoded). Powers dynamic NFTs and rich object annotations. Returns unsigned JSON + preflight. Never signs; testnet by default.
Inputs: account (required), remarks (required), objectId (required), network.
build_signer_list_set_unsignedA
ROTATION WIZARD alt — assemble an UNSIGNED SignerListSet (multisig). Often SAFER than disable-master for high-value accounts: multiple recovery keys, no single point of loss. quorum=0 removes the list. Rejects an unreachable quorum (would lock out the account). Never signs.
Inputs: quorum (required), account (required), network, signers.
check_amendment_blockedA
Report whether the configured RPC node for this network is AMENDMENT BLOCKED (running xahaud too old to understand an enabled amendment — can't validate, submit, or vote), plus its build version and validated ledger. Reads server_info. Checks the network's fixed endpoint (no arbitrary-URL input, by design). 1 RPC read.
Inputs: network. Returns: note, error, remedy, network, +5 more
classify_hookB
Infer in plain English what a Hook DOES (firewall/filter, emitter, stateful processor, financial/XFL, authorizer, autonomous agent…) from its structure — imports, hook/cbak exports, HookOn, state/emit/float/guard usage. Heuristic, offline; does not execute the bytecode.
Inputs: hookOn, wasmHex, wasmBase64. Returns: error, valid, firesOn, summary, +4 more
compute_rewardA
Project claimable XAH network reward using the documented time-weighted model. Supply reward fields directly, or an address to read them live. Labelled DOCUMENTED_MODEL. LEGACY approximation — prefer reward_status, which applies the exact genesis reward-hook formula with live parameters.
Inputs: address, network, balanceXAH, currentLedger, +2 more.
currency_codeA
Convert a currency between 3-char ISO code (e.g. USD) and its 160-bit/40-hex form. Non-standard 160-bit codes pass through. Offline.
Inputs: input (required).
decode_amountA
Decode an amount: native drops (digits), a serialized 8-byte native or 48-byte issued STAmount (hex), or an issued amount object {currency,issuer,value} → normalized value/currency/issuer. Offline.
Inputs: amount (required). Returns: xah, type, drops, error, +4 more
decode_b2mC
Heuristically classify a Burn2Mint-related transaction (XRPL↔Xahau bridge direction). Offline.
Inputs: tx (required).
decode_hook_can_emitA
Decode a HookCanEmit 256-bit bitmap into the set of transaction types a hook is permitted to EMIT (HookCanEmit amendment). Same encoding as HookOn (inverted/active-low, active-high SetHook bit). NOTE: an ABSENT HookCanEmit field means the hook may emit ANY transaction (including SetHook) — this tool only decodes a present value. Offline.
Inputs: hookCanEmit (required).
decode_hook_onA
Decode a HookOn 256-bit bitmap into the set of transaction types the hook fires on. Handles the inverted/active-low encoding and the active-high SetHook bit. Offline.
Inputs: hookOn (required). Returns: count, error, hookOn, firesOn
decode_lease_uriA
Decode an Evernode lease URIToken URI (the evrlease/LTV format) → lease index, lease amount in EVR (XFL-decoded), half ToS hash, mint identifier, outbound IP. Accepts the on-chain URI hex, the base64 text, or raw buffer hex. Verified against the canonical evernode-js-client encoder + real mainnet leases. Offline.
Inputs: uri (required).
decode_resultA
Decode a transaction engine result code (e.g. 0/tesSUCCESS, 153/tecHOOK_REJECTED) ⇄ its name. Accepts a number or the result-code name. Offline.
Inputs: result (required).
decode_sethookA
Decode a SetHook transaction (JSON or tx blob) into its hook definitions, each with HookOn decoded. Offline.
Inputs: tx, txBlobHex.
decode_sign_requestA
Decode a sign request (a Xaman/Xumm payload's txjson, or a raw tx_blob hex) into the transaction plus a plain-English 'what you would be authorizing' summary and safety warnings (SetHook, AccountDelete, key changes, no-expiry, already-signed). Offline — understand before you sign.
Inputs: txjson, txBlobHex. Returns: tx, error, summary, warnings, +2 more
decode_tx_blobA
Decode a Xahau transaction blob (hex) into JSON via the Xahau-aware binary codec. Offline.
Inputs: txBlobHex (required).
decode_uritoken_idA
Validate a URIToken ID and explain its structure (SHA512-Half of issuer||URI; not reversible offline). Offline.
Inputs: uriTokenId (required).
decode_xpopA
Decode an XPOP (Xahau Proof of Payment) — the proof blob inside an Import/Burn2Mint tx. Accepts the Import Blob hex (hex of the XPOP JSON) or the XPOP JSON itself. Returns the source ledger header, the decoded inner BURN transaction (type, burned drops = its Fee, target network), and the UNL validator set. Offline.
Inputs: xpop (required). Returns: error, ledger, summary, warnings, +8 more
diagnose_failed_txA
Why did my transaction fail? Plain-English diagnosis from ON-CHAIN facts: engine result decoded to cause + concrete fix (catalog of ~30 common Xahau failure codes), hook rollback return-strings decoded and interpreted (e.g. the genesis reward hook's 'You must wait N seconds' becomes a claimable-at date), the partial-payment trap on 'successful' Payments (delivered_amount vs Amount), and not-found triage (expired LastLedgerSequence / wrong network). 1 RPC read; authoritative — decodes what the chain recorded, re-executes nothing (use hook_execution_postmortem to replay hooks).
Inputs: txHash (required), network. Returns: error, fixes, found, notes, +12 more
diff_node_amendmentsA
Diff the enabled-amendment sets of two networks (e.g. mainnet vs testnet) — what's enabled on one but not the other, by name where known. Explains why a transaction or Hook feature works on one network but not the other. 2 RPC reads.
Inputs: a, b. Returns: a, b, error, onlyOnA, +4 more
disable_master_readinessA
ROTATION WIZARD gate — is it SAFE to disable this account's master key? Checks for a working alternative signer: proves whether the configured regular key has ALREADY signed for the account (gold standard) and whether a signer list exists. Returns safeToDisable + proven + reasons. Read-only. Run this BEFORE build_disable_master_unsigned.
Inputs: account (required), network.
encode_hook_can_emitB
Build a canonical HookCanEmit hex from the list of transaction types a hook should be allowed to emit (HookCanEmit amendment; same encoding as HookOn). Omit the field entirely on the SetHook to allow emitting anything. Offline.
Inputs: txTypes (required).
encode_hook_onA
Build a canonical HookOn hex from a list of transaction types to fire on. Offline.
Inputs: txTypes (required). Returns: error, hookOn, firesOn
encode_tx_blobA
Encode a transaction JSON into an UNSIGNED Xahau binary blob (for inspection/round-trip; never signed). Offline.
Inputs: tx (required).
estimate_hook_feeA
Estimate a Hook's cost signals from its WASM: byte size (drives the SetHook fee) and total static instruction count (a complexity/upper-bound proxy for execution fee). Labelled ESTIMATE — the on-ledger execution fee depends on the path actually executed. Offline.
Inputs: wasmHex, wasmBase64.
estimate_hook_state_costA
Compute the owner-reserve cost of Hook State entries under ExtendedHookState. Given each entry's value size in bytes and the HookStateScale (1–16), returns per-entry capacity (256×scale bytes), per-entry reserve units (= scale, charged even for 1 byte), total reserve units, overflow warnings, and the minimum scale needed. Reserve UNITS are exact; pass ownerReserveIncrementXah to also get an XAH figure. Offline.
Inputs: entries (required), scale, ownerReserveIncrementXah.
evernode_host_diagnosticsA
One-call health check for an Evernode host (the official docs' troubleshooting checklist, automated): registration entry on the governor namespace, heartbeat liveness vs the on-chain active rule (current moment − heartbeatFreq×momentSize), instance load, reputation byte, EVR trustline + balance, registration URIToken held, lease offers, machine specs + accumulated EVR reward. Layout verified against canonical evernode-js-client + live mainnet. Read-only; ~9 serial RPC reads (slow but thorough).
Inputs: address (required), network. Returns: error, notes, specs, checks, +9 more
execute_hookA
GROUNDBREAKING: actually RUN a Hook's real WebAssembly bytecode in a local VM against a simulated transaction + ledger state, and report the true accept/rollback decision, return code/string, state writes, emitted txns and execution trace. The first dev-accessible Hook simulator that needs no xahaud node. Implements a subset of the Hook API; unsupported calls are recorded (fidelity LOCAL_VM, never faked).
Inputs: state, txType, feeBase, network, +10 more. Returns: exit, error, trace, caveat, +14 more
explain_accountA
One-call plain-English account snapshot: balance, key-safety read (master/regular key), installed Hooks (+what they fire on), trustlines, URITokens (Evernode leases auto-decoded), and recent activity — plus warnings and notes. Read-only; exactly 5 serial RPC reads (>=1100ms apart).
Inputs: address (required), network.
fuzz_hookA
DIFFERENTIAL FUZZER: finds a Hook's accept/rollback decision boundary by running its REAL bytecode through the local VM against many DETERMINISTICALLY generated inputs (no randomness, no clock — fully reproducible). Sweeps axes you request: txType (a supplied list or all tx types), a raw otxn Amount-field byte range, otxn account/destination ids, and named otxn params. Reports counts {accept,rollback,halted,degraded}, per-axis boundary findings, and concrete accepting/rejecting sample inputs. Honest: degraded/halted runs are counted but excluded from the boundary; if every run degrades/halts it says INCONCLUSIVE and why. fidelity LOCAL_VM_FUZZ.
Inputs: state, txType, feeBase, samples, +14 more.
get_account_hooksB
The Hooks installed on an account, with each HookOn bitmap decoded to the transaction types it fires on. Read-only.
Inputs: address (required), network.
get_account_infoC
Account root: balance, sequence, flags, regular key. Read-only.
Inputs: address (required), network.
get_account_linesC
Trustlines (issued-currency balances) held by an account. Read-only.
Inputs: address (required), network.
get_account_objectsA
Ledger objects owned by an account, optionally filtered by type (hook, hook_state, uri_token, etc.). Read-only.
Inputs: address (required), type, network.
get_account_offersC
Open DEX offers placed by an account. Read-only.
Inputs: address (required), network.
get_account_uritokensC
URITokens (Xahau-native NFTs) owned by an account, with each token's URI decoded from hex to text. Read-only.
Inputs: address (required), network.
get_amendment_statusA
Live amendment status for the network: every ENABLED amendment (resolved to its human name where known, raw hash otherwise) plus any in the VOTING set (already at >80% support, counting toward enablement). Reads the on-ledger Amendments singleton — no admin node needed. 1 RPC read.
Inputs: network. Returns: error, caveat, voting, enabled, +7 more
get_feeA
Current network transaction fee (base fee in drops + load/queue state) — for building a tx with the right Fee. Read-only.
Inputs: network.
get_hook_definitionA
Fetch a HookDefinition ledger object by hash (CreateCode WASM, HookOn, fee, reference count). Read-only.
Inputs: hookHash (required), network.
get_hook_stateB
Read Hook State entries for an account namespace (32-byte key→value map). Read-only.
Inputs: address (required), namespace (required), network.
get_ledgerA
Header/summary of a ledger (default the latest validated). Read-only.
Inputs: network, ledgerIndex.
get_transactionA
A validated transaction by hash, including Xahau HookExecutions metadata (hook return codes/strings). Read-only.
Inputs: txHash (required), network.
governance_stateA
Genesis Governance Game — FULL live decode of the L1 table's hook state (layout canonical from xahaud hook/genesis/govern.c): all 20 seats and their members, member count, live reward rate/delay, every OPEN VOTE (who voted what, per topic) and every tally with its threshold (membership topics 80% of filled seats, everything else 100%) and whether it's reached. Plus the documented constants + a live genesis-account read. 2 RPC reads.
Inputs: network.
hndl_exposureA
Measure an account's Harvest-Now-Decrypt-Later exposure: has its signing PUBLIC KEY been revealed on-ledger, and which key? An r-address is a HASH of the pubkey; the pubkey is exposed only once the account signs a tx. Walks history OLDEST-first and classifies: master (IRREVERSIBLE — master key can't be rotated), regular / multisig (RECOVERABLE — rotate the key), or none (never signed = hash-only, not Shor-actionable). Reports balance-at-risk + honest truncation caveat. Read-only.
Inputs: address (required), network, maxPages. Returns: note, error, address, exposed, +15 more
hook_api_lookupA
Look up a Hook API function: category, exit/guard role, and security hazard metadata. Offline.
Inputs: name (required).
hook_diffA
Compare two Hook versions (before/after an upgrade): imports/exports added or removed, HookOn changes, size/instruction deltas, and any newly-gained security-sensitive capability (emit, foreign-state write, hook_again, signature verify). Offline.
Inputs: afterHookOn, afterWasmHex, beforeHookOn, beforeWasmHex, +2 more. Returns: error, exports, firesOn, imports, +8 more
hook_dry_runA
Quick STATIC check: does this hook fire on a given transaction type (HookOn match) and what exit calls does its WASM contain? Labelled STATIC_ONLY. For REAL bytecode execution use execute_hook. Offline.
Inputs: hookOn (required), candidateTxType (required), wasmHex, wasmBase64.
hook_execution_postmortemA
POST-MORTEM a real Xahau transaction's hooks: fetch the tx (with meta.HookExecutions + engine result), then for EACH hook that fired, run its REAL bytecode through the local VM and compare the VM's accept/rollback DIRECTION to what the chain actually recorded. Answers 'why did these hooks accept/rollback, and would the VM agree?'. The on-chain decision is AUTHORITATIVE; the VM run is best-effort and always labeled fidelity=LOCAL_VM. agree is null (not false) when the VM run is degraded/halted/no-exit or the on-chain decision is indeterminate (e.g. no CreateCode available) — never scored as a match or miss. Read-only; never signs/submits. Serial rate-limited RPC: 1 tx call + 1 ledger_entry per UNIQUE HookHash (deduplicated), each >=1100ms apart; tolerates literal 'Rate limited' bodies via the shared client.
Inputs: txHash (required), network.
hook_reportB
One-call comprehensive report on a Hook: structure (imports/exports/size/instructions), a plain-English classification of what it does, the full security analysis (SARIF-lite findings + severity summary), HookOn decode, and a fee estimate. Combines inspect + classify + analyze + estimate. Offline.
Inputs: grants, hookOn, wasmHex, namespace, +1 more. Returns: error, verdict, analysis, structure, +3 more
inspect_emitted_txA
Decode what a hook's emit() actually built: pass the emitted[] blob hex(es) from an execute_hook result → each decoded to tx JSON + a plain-English 'what it tries to send' summary + danger score (scam rules). Closes the loop on emitter hooks. Offline.
Inputs: emitted (required).
inspect_hook_wasmA
Parse a Hook's CreateCode WASM (hex or base64): imports (Hook API functions), exports (hook/cbak), memory, custom sections, loop and guard(_g) counts. Offline, never executes the module.
Inputs: wasmHex, wasmBase64.
list_cron_jobsA
List an account's Cron ledger objects — scheduled Hook self-invocations — with decoded StartTime (ISO), DelaySeconds, remaining RepeatCount and an estimated next-fire time. Raw ledger object included per entry. 1 RPC read.
Inputs: account (required), network.
list_rulesA
Enumerate the Hook analyzer rule registry (id, severity, title, category). Offline.
Inputs: no named parameters.
master_pubkeyA
Derive an account's MASTER public key from the ledger — the SigningPubKey of any self-originated tx whose pubkey hashes to the account's own AccountID. Needed to configure a qkey_guard hook (its MPK param). Returns found=false if the master key has never signed (then the pubkey is not on-ledger). Read-only.
Inputs: account (required), network.
monitor_cron_healthA
Check an account's Crons for ones nearing exhaustion — remaining RepeatCount at or below a threshold (default 8) — so a recurring governance/game Hook doesn't silently stop. Returns alerts + a healthy flag. 1 RPC read.
Inputs: account (required), network, lowThreshold.
predict_amendment_activationA
Project when amendments now holding majority will enable. For each amendment in the on-ledger Majorities set: when it reached >80% support and its estimated enable time (majority + 5-day Xahau window), with seconds/days remaining. Reads the Amendments singleton — no admin node needed. 1 RPC read.
Inputs: network. Returns: error, caveat, network, pending, +3 more
prepare_transactionA
Autofill an unsigned transaction with live network values — Sequence (from the account), Fee (current base fee), LastLedgerSequence (now + offset), and NetworkID — so it's ready to sign OFFLINE. Read-only: fetches values, fills the tx, but NEVER signs or submits. Defaults to TESTNET — pass network:'mainnet' for a mainnet account (else you get a mainnet account's testnet Sequence/NetworkID or actNotFound).
Inputs: tx (required), network, lastLedgerOffset.
quantum_config_censusA
WHOLE-LEDGER key-rotation posture census via ledger_data (AccountRoot Flags/RegularKey/Balance) — no per-account tx scan, so figures ARE network statistics. Reports % of accounts AND % of XAH supply with: no rotation path (master active + no regular key), master disabled, regular key set. Measures CONFIG (can the master key be retired?), not exposure (hndl_exposure does that). HEAVY + rate-limited; paced. Read-only.
Inputs: delayMs, network, maxPages, pageLimit. Returns: error, caveat, network, accounts, +13 more
quantum_gradeA
Grade a Xahau account for quantum (HNDL) FUTURE-hardening readiness: master-key-disabled, regular key, multi-sign, and a PROVEN quantum-policy Hook → 0-100 score + tier + recommendations. Framed as hardening, not a safety alarm (a BASELINE account is normal, not unsafe). A hook is credited (+30) ONLY when its exact bytecode (HookHash) matches a registered xahc-prover-PROVEN quantum-policy hook (e.g. qkey_guard / master-disuse); mere hook presence is never scored. Read-only.
Inputs: address (required), network. Returns: tier, error, hooks, score, +10 more
quantum_scorecardA
Network-level Quantum Readiness Scorecard: aggregate HNDL exposure (hndl_exposure) + config grade (quantum_grade) across a SAMPLE of accounts. HONEST SCOPE: a sample of recently-active accounts (or a caller-supplied list), NOT a ledger census — active accounts skew toward exposed, so figures are a sample, not a network %. Reports exposure-class breakdown, balance-at-risk, conclusive-vs-unknown, grade tiers, and top exposed. HEAVY (many RPC reads). Set --markdown for a public-facing report. Read-only.
Inputs: cap, network, accounts, markdown, +2 more. Returns: rows, error, caveat, network, +19 more
reward_statusA
Balance Adjustment doctor — the full answer to Xahau's most common retail question: is this account opted in to network rewards, how much XAH is accrued (EXACT genesis reward-hook formula — reward.c — with live RR/RD read from genesis hook state), when can it next claim, and is the claim overdue (late claiming forfeits yield — the hook pays the per-claim rate once regardless of wait). Returns an unsigned opt-in or claim ClaimReward when applicable. Read-only; 3 serial RPC reads.
Inputs: address (required), network. Returns: error, notes, fields, params, +10 more
ripple_timeA
Convert between Ripple time (seconds since 2000-01-01), Unix time, and ISO 8601. Xahau tx/ledger timestamps use Ripple time. Offline.
Inputs: iso, unix, ripple.
scaffold_hookA
Generate a starter Xahau Hook in C for a stated intent (accept_all, firewall, payment_limit, require_dest_tag, state_counter, notary) — structurally valid (hook() entry, _g guards, accept/rollback) with build instructions. A STARTING POINT to compile + then verify with analyze_hook/execute_hook before deploying. Offline.
Inputs: archetype (required), maxDrops, blockTxType.
scam_checkA
Score a sign request (txjson or raw tx_blob hex) for risky patterns BEFORE signing: returns dangerScore 0-100, a SAFE/CAUTION/DANGER tier, a plain-English verdict, and per-rule findings (SetHook, AccountDelete-to-other, regular-key/signer-list changes, very large native payment, no-expiry replay risk, pre-signed blob). Offline + read-only. HONESTY: every finding is a POTENTIAL risk, NOT a confirmed scam — this tool does NOT consult any block list and NEVER verifies on-chain whether an address is malicious; it reads the transaction shape only. DANGER is reserved for near-universally-malicious/irreversible patterns.
Inputs: txjson, txBlobHex.
simulate_hook_triggerA
Statically predict which accounts' hooks a transaction WOULD invoke (transactional stakeholders), with strong (can rollback) vs weak (runs, can't rollback) roles — from the tx fields alone, no bytecode run and no ledger read. For tx types whose stakeholders require ledger-object lookups it returns a partial flag rather than guessing. For a full prediction that runs the real hook bytecode against live state, use simulate_transaction. Offline.
Inputs: tx (required).
simulate_transactionA
THE PRE-SIGN FLIGHT SIMULATOR — predict what Xahau will do with an UNSIGNED transaction before you sign it. Every hook the tx would trigger (originator chain first, then strong/weak transactional stakeholders — order canonical from xahaud Transactor.cpp/applyHook.cpp) runs as REAL bytecode against LIVE ledger state in the local VM (measured 100% agreement on 30 real mainnet hook executions — all accept-direction; rollback direction proven separately on real genesis bytecode). Reports per-hook accept/rollback + return strings, simulated state writes, decoded emitted transactions, labeled STATIC engine preflights (sequence/balance/destination/expiry), an APPROXIMATE transactor prediction (the stand-in for Xahau's missing simulate RPC — predicted engine_result + balance/reserve/trustline deltas for Payment/TrustSet against live state, labeled APPROXIMATE; other tx types UNSUPPORTED), and a scam score. Never signs, never submits. Slow but thorough (iterative state resolution, ~1.1s per read).
Inputs: tx (required), network. Returns: error, notes, caveat, summary, +9 more
trace_transaction_stakeholdersA
Every account a transaction touched, from its metadata (AffectedNodes). Because the Touch amendment forces all transactional stakeholders into metadata — even ones nothing else changed for — this is the authoritative participant list, not a guess from tx fields. Returns each account with its roles, the ledger entry types it appeared in, and whether it materially changed. 1 RPC read.
Inputs: txHash (required), network. Returns: note, error, txHash, network, +5 more
validate_addressA
Validate a Xahau/XRPL address (classic r-address or X-address) → type, account-id, embedded destination tag, network. Offline.
Inputs: address (required). Returns: tag, type, error, valid, +4 more
verify_double_threadingA
Structural audit of a transaction's metadata threading — lists each affected ledger object's PreviousTxnID / PreviousTxnLgrSeq and flags the duplicate-node symptom that fixProvisionalDoubleThreading addressed (a single ledger object touched by more than one AffectedNodes entry). Metadata-only check; does not walk the full cross-ledger thread. 1 RPC read.
Inputs: txHash (required), network. Returns: error, caveat, txHash, entries, +6 more
vm_fidelity_reportA
HONEST FIDELITY METRIC: measures how faithfully the local Hook VM reproduces what REALLY happened on Xahau mainnet. Loads a committed corpus (data/hook-corpus.json) of real validated transactions whose metadata carried HookExecutions, runs each hook's real bytecode through the local VM, and compares the VM's accept/rollback DIRECTION to the on-chain HookResult. The agreement % is computed ONLY over COMPARABLE (non-degraded, scoreable) runs; degraded/halted/indeterminate runs are reported separately and EXCLUDED — never counted as a match. Strictly offline; reads no network. If the corpus is empty/tiny it says 'insufficient corpus' rather than print an unsupported number.
Inputs: includeMismatches. Returns: error, total, perHook, headline, +8 more
what_ifA
TIME MACHINE — counterfactual replay of a REAL historical transaction: fetch it by hash, apply your field overrides (different Amount, Destination, params, ...), then run the full flight simulator AT THAT HISTORICAL LEDGER (hooks, state and parameters as they were). Answers 'what would have happened if this tx had been X?'. Read-only; nothing is signed or submitted.
Inputs: txHash (required), network, overrides. Returns: error, notes, caveat, summary, +9 more
xaddressA
Encode a classic address + destination tag into an X-address, or decode an X-address back to classic + tag. Offline.
Inputs: address (required), tag, test.
xah_amountA
Convert between XAH and drops (1 XAH = 1,000,000 drops). Offline.
Inputs: from (required), value (required).
xahau_server_infoA
Health, version, amendments and ledger range of a Xahau node (mainnet or testnet). Read-only.
Inputs: network.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 87 tools
The tool descriptions are unusually precise, but the set has several closely related clusters: analyze_hook/hook_report/classify_hook, execute_hook/simulate_transaction/simulate_hook_trigger, compute_reward/reward_status, and the four quantum tools. An agent will often need to read long descriptions carefully to avoid selecting a sibling tool with a similar name.
The overwhelming majority of tools follow a verb_noun snake_case pattern (get_account_info, decode_tx_blob, build_payment_unsigned, simulate_transaction). A minority use noun-style names (xahau_server_info, reward_status, hndl_exposure, what_if), but there is no camelCase or random style mixing, so the pattern remains readable and predictable.
87 tools is far beyond the well-scoped 3-15 range and above the 50+ extreme threshold. Even for a broad Xahau platform, this is an excessive surface area that could be consolidated or split into purpose-specific servers.
The toolkit covers the Xahau domain deeply: account reads, hook inspection/analysis/simulation, unsigned transaction builders, amendment tracking, rewards, cron, and quantum diagnostics. Minor gaps remain—no generic submit path (by design), no generic ledger-object fetch, and no general TrustSet/AccountSet builder for arbitrary edits—but the major workflows have no dead ends.
Maintenance
Related MCP Connectors
Self-hosted MCP server: 26 deterministic dev, security, and EVM tools.
MCP server for Klever blockchain smart contract development.
Read-only XRP Ledger MCP tools with proof-annotation envelopes and signed daily snapshots.
Read-only MCP server for the WebAssembly spec: instructions, types, sections, search, proposals.
Related MCP Servers
- AlicenseAqualityBmaintenanceMCP server for local transaction signing across EVM, UTXO, Tron, and XRP blockchains, with no network calls or API keys required.7425 npmMIT
- AlicenseAqualityCmaintenanceMCP server for Stellar that provides tools for accounts, payments, XDR, Horizon/Soroban RPC, AMM liquidity, SEP anchors, and Soroban contract operations.294 npmMIT
- AlicenseNot gradedqualityDmaintenanceLow-level blockchain interface MCP server for Algorand and Voi networks, providing account/asset/app inspection, transaction search, block retrieval, TEAL compilation, and transaction simulation.MIT
- AlicenseNot gradedqualityCmaintenanceA local-first MCP server for financial wire message forensics, providing read-only tools to parse, validate, and detect SR2026 address compliance in ISO 8583, SWIFT MT, and ISO 20022 messages.Apache 2.0