Skip to main content
Glama

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.

xahau-mcp v2.0 flight simulator demo

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

xahc

author + compile a safe Hook to clean, lint-passed WASM

simulate one

xahau-mcp

run the real bytecode against one live transaction

prove all

xahc-prover

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_transaction is 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 sibling what_if is a time machine: replay any real historical transaction — with your modifications — at its original ledger. Verified to reproduce a real claim's emitted GenesisMint payout to the drop (72,251,963 drops), test-locked.

  • Run a Hook without deploying it — execute_hook instantiates the real CreateCode WASM in a local VM, supplies the Hook API over a simulated transaction + ledger state, and reports the actual accept/rollback decision, return code/string, state writes, emitted transactions and a call trace. No xahaud node 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/rollback exit, unguarded loops (_g), unknown env imports, dangerous HookGrants, over-broad HookOn, and more.

  • Decode the cryptic HookOn bitmap 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 HookExecutions metadata), ledgers.

  • Answer the #1 retail question — reward_status tells 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_diagnostics automates 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_tx turns an engine result + hook return strings into a plain-English cause and a concrete fix.

  • Watch governance live — governance_state decodes 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):

  1. Executes real on-chain contract bytecode in a LOCAL VM — execute_hook runs the actual CreateCode WASM with no node, no cloud, no account. Not an ABI wrapper, not a hosted simulator.

  2. Publishes a measured, regression-locked fidelity score against chain ground truth — vm_fidelity_report replays 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 (governance Invoke → rollback) in tests/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.

  3. In-protocol static security analysis — a Hooks-specific rule engine (SARIF-lite findings), calibrated against the network's own genesis hooks.

  4. In-protocol differential fuzzing — fuzz_hook maps a contract's accept/reject decision boundary in the local VM.

  5. Post-mortems real transactions with real bytecode — hook_execution_postmortem replays what actually fired on chain and compares.

  6. Reproduces on-chain economics exactly — reward_status re-implements the genesis reward hook's formula and reproduces a real emitted payout to the drop (verified, test-locked).

  7. Decodes live governance end-to-end — governance_state shows every seat, vote, tally and threshold of the Governance Game, live.

  8. 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 submit and no sign anywhere 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_hook runs 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 against float_one; float_root/float_log are the exceptions — they return NOT_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:true fetches 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_set records the write but does NOT model the on-chain HookGrant requirement; etxn_details serves a disclosed SYNTHETIC placeholder (listed in syntheticCalls, 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 real NOT_IMPLEMENTED code, are listed in unsupportedCalls, and mark the run degraded — never faked. The VM models the guard budget (_g enforces each guard's declared maxiter → GUARD_VIOLATION), and reports stateApplied (state writes commit only on accept, discarded on rollback). It is not a consensus-faithful xahaud replica — it has no fee/fuel metering beyond guards, XFL math truncates rather than round-half-up (so float_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 _g guard 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_run is STATIC_ONLY, compute_reward is DOCUMENTED_MODEL (legacy — prefer reward_status, whose REWARD_HOOK_FORMULA re-implements reward.c exactly and reproduces a real on-chain GenesisMint payout to the drop), estimate_hook_fee is ESTIMATE.

  • 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

execute_hook

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

simulate_transaction

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. Named hooks: a hook installed with a HookName runs only when the tx carries the same HookName (otherwise reported not fired: hook requires HookName …). EscrowFinish/EscrowCancel: the escrow owner (Owner + OfferSequence) runs as a strong stakeholder; the destination is flagged, not guessed.

what_if

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).

fuzz_hook

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).

annotate_hook_trace

Decode an execute_hook 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.

hook_report

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

hook_execution_postmortem

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 LOCAL_VM; agree is null (not false) when degraded/indeterminate. Serial RPC: 1 tx + 1 ledger_entry per unique HookHash.

vm_fidelity_report

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

classify_hook

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

hook_diff

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

scaffold_hook

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

analyze_hook

Run the static-analysis rule engine over a hook → SARIF-lite findings.

audit_account_hooks

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

inspect_hook_wasm

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

estimate_hook_fee

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

hook_dry_run

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

list_rules · hook_api_lookup

Enumerate analyzer rules · look up a Hook API function's role & hazards.

Codec / decode (offline)

Tool

Purpose

decode_hook_on / encode_hook_on

HookOn bitmap ⇄ transaction-type list.

decode_hook_can_emit / encode_hook_can_emit

HookCanEmit bitmap ⇄ the tx types a hook may emit (HookCanEmit amendment; absent = may emit anything).

estimate_hook_state_cost

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

simulate_hook_trigger

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

decode_sethook

A SetHook tx → its hook definitions, HookOn decoded.

decode_tx_blob / encode_tx_blob

Xahau tx blob ⇄ JSON (unsigned).

decode_uritoken_id · xah_amount

URIToken ID validation · XAH⇄drops.

decode_xpop

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

decode_result

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

diagnose_failed_tx

"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 LastLedgerSequence / wrong network). 1 read.

validate_address · xaddress

Validate classic/X-address (type, account-id, tag) · encode/decode X-addresses.

currency_code · ripple_time

3-char ISO ⇄ 160-bit currency · Ripple-time ⇄ Unix/ISO.

decode_amount

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

decode_sign_request

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

decode_lease_uri

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

evernode_host_diagnostics

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 evernode-js-client + a live mainnet host (~9 serial reads).

inspect_emitted_tx

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

scam_check

Score a sign request (txjson or tx_blob) 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 potential risk, never a confirmed scam; no block-list lookup, no on-chain malice check.

Ledger (read-only RPC)

Tool

Purpose

xahau_server_info · get_account_info · get_account_objects

Node/account reads.

get_account_hooks · get_hook_definition · get_hook_state

Hook reads. get_account_hooks shows each hook's HookName (a named hook fires only for txs carrying that name).

get_transaction · get_ledger · get_fee

Tx (with HookExecutions) · ledger · current network fee.

get_account_lines · get_account_offers · get_account_uritokens

Trustlines · DEX offers · URITokens (NFTs, URI decoded).

explain_account

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

Economics / governance

Tool

Purpose

reward_status

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 unsigned opt-in/claim ClaimReward when applicable (3 serial reads).

compute_reward

Project claimable XAH network reward (DOCUMENTED_MODEL; legacy — prefer reward_status).

quantum_grade

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

governance_state

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.

decode_b2m

Burn2Mint classification.

Amendment intelligence (read-only, no admin node)

Tool

Purpose

get_amendment_status

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.

predict_amendment_activation

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.

check_amendment_blocked

Is the configured node amendment blocked (xahaud too old to read an enabled amendment)? Build version, validated ledger, upgrade remedy.

diff_node_amendments

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

trace_transaction_stakeholders

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).

verify_double_threading

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

audit_account_remarks

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

build_sethook_unsigned

UNSIGNED SetHook with automatic analyze_hook preflight. On a CRITICAL finding the tx is withheld and only the findings return, unless overrideCritical: true.

build_claimreward_unsigned · build_import_unsigned · build_payment_unsigned

UNSIGNED ClaimReward · Import/B2M · Payment.

build_remit_unsigned

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 AmountEntry/MintURIToken nesting; auto trustline/reserve/account-create semantics; optional third-party Inform. Payload preflight included.

build_set_remarks_unsigned

UNSIGNED SetRemarks (Remarks amendment) — attach/update/delete key-value remarks on a ledger object you own/issue. immutable (tfImmutable) support, delete-by-omission, 32-max + uniqueness + size guards. Powers dynamic NFTs.

build_clawback_unsigned

UNSIGNED Clawback — issuer revokes issued tokens from a holder (Amount.issuer = holder, the canonical gotcha). Opt-in + XAH guards.

build_deepfreeze_unsigned

UNSIGNED TrustSet freeze toggle — deep_freeze (blocks send+receive), freeze, and their clears, mapped to the correct tfSetDeepFreeze/tfSetFreeze flags.

prepare_transaction

Autofill Sequence/Fee/LastLedgerSequence/NetworkID from the live network → ready to sign offline (never signs).

Cron (scheduled Hook execution)

Tool

Purpose

build_cronset_unsigned

UNSIGNED CronSet — schedule a Hook's future self-invocations: StartTime (Ripple-epoch, 0=ASAP) or startInSeconds, RepeatCount (0–256), DelaySeconds, or cancel (tfCronUnset). Preflight catches recurring-without-interval and no-Hook cases.

list_cron_jobs

Read an account's Cron ledger objects with decoded StartTime (ISO), DelaySeconds, remaining RepeatCount, and an estimated next-fire time (raw object included).

monitor_cron_health

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 read

Run 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-mcp

Claude 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 suite

Older 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-http

On 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

POST /simulate

{ tx, network?, ledgerIndex?, candidateCode?, candidateHookOn?, candidateNamespace?, candidateHookName? }

full Simulation — per-hook accept/rollback, decoded emits, state writes, static preflights

POST /what-if

{ txHash, overrides?, network? }

Simulation of a real historical tx re-run (with your overrides) at its original ledger

POST /execute

{ wasmHex, txType?, otxnFields?, hookAccountId?, state?, … }

SandboxResult — run a hook's bytecode in isolation (offline, no RPC)

POST /analyze

{ wasmHex, hookOn?, namespace?, … }

{ findings, summary } — the static rule engine (offline, instant, the cheap top-of-funnel)

GET /fidelity

—

the VM fidelity report + corpusHash + lastRun (echoes the accept-only coverageWarning verbatim)

GET /health

—

{ ok, inflight, endpoints }

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

PORT

8787

listen port

RL_MAX

20

requests / IP / minute

MAX_INFLIGHT

4

concurrent simulations

XAHC_HOOK_TIMEOUT_MS

3000

hard wall-clock per hook execution

XAHC_HOOK_MEM_MB

256

memory cap per hook execution

XAHC_SIM_SPACING_MS

sim default

inter-read RPC spacing — 0 for your own node, ~300 behind a shared public node

TRUST_PROXY

unset

set only when behind a reverse proxy that sets X-Forwarded-For

XAHAU_RPC_URLS

data/endpoints.json

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_PROXY when genuinely behind a proxy that sets X-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/submit anywhere; builder tools never accept a secret and only emit unsigned transactions to sign offline.

  • No code-exec surface — no eval/Function, no child_process/shell, no filesystem writes, no dynamic require. RPC fetch only ever hits the fixed endpoints in data/endpoints.json (or your XAHAU_RPC_URLS / XAHAU_TEST_RPC_URLS overrides for mainnet/testnet) — never a URL built from tool input, so no SSRF.

  • Untrusted Hook WASM is sandboxed — execute_hook/fuzz_hook run 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 _g guard 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 audit reports only low-severity advisories transitively under xrpl-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, and xrpl-accountlib (used only for the Xahau-aware binary codec; its signing surface is never called). RPC is plain fetch; the WASM reader is hand-rolled and zero-dep; the VM uses Node's built-in WebAssembly engine 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's server_definitions and the canonical Hook API list (Xahau/hooks-rs c/extern.h) via npm 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 tools
analyze_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

    B3.2/5.0

    Scored across 87 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count1/5

    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.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      MCP server for Stellar that provides tools for accounts, payments, XDR, Horizon/Soroban RPC, AMM liquidity, SEP anchors, and Soroban contract operations.
      29
      4 npm
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Low-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
    • A
      license
      Not graded
      quality
      C
      maintenance
      A 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