Xahau MCP

Run the Hook static-analysis / security rule engine over a CreateCode WASM (+ optional SetHook params) and return SARIF-lite findings. Offline.

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.

Fetch every hook on an account, pull each HookDefinition's WASM, and run the analyzer over all of them. Read-only network + offline analysis.

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.

Assemble an UNSIGNED ClaimReward transaction. Returns unsigned JSON + offline signing instructions. Never signs; testnet by default.

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.

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.

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.

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.

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.

Assemble an UNSIGNED XAH Payment (amount in drops). Returns unsigned JSON + offline signing instructions + payload preflight. Never signs; testnet by default.

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.

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.

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.

Assemble an UNSIGNED SetHook transaction from CreateCode + params, auto-running analyze_hook as preflight. On any CRITICAL finding the unsigned tx is WITHHELD (unsignedTx null) and only the findings come back, unless overrideCritical is true. Returns findings + unsigned JSON + offline signing instructions. Never signs; testnet by default.

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.

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.

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.

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.

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.

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.

Heuristically classify a Burn2Mint-related transaction (XRPL↔Xahau bridge direction). Offline.

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.

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.

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.

Decode a transaction engine result code (e.g. 0/tesSUCCESS, 153/tecHOOK_REJECTED) ⇄ its name. Accepts a number or the result-code name. Offline.

Decode a SetHook transaction (JSON or tx blob) into its hook definitions, each with HookOn decoded. Offline.

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.

Decode a Xahau transaction blob (hex) into JSON via the Xahau-aware binary codec. Offline.

Validate a URIToken ID and explain its structure (SHA512-Half of issuer||URI; not reversible offline). Offline.

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.

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

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.

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.

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.

Build a canonical HookOn hex from a list of transaction types to fire on. Offline.

Encode a transaction JSON into an UNSIGNED Xahau binary blob (for inspection/round-trip; never signed). Offline.

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.

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.

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

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. Needs no xahaud node. Implements a subset of the Hook API; unsupported calls are recorded (fidelity LOCAL_VM, never faked).

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

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.

The Hooks installed on an account, with each HookOn bitmap decoded to the transaction types it fires on, and any HookName (a named hook fires only for transactions carrying the matching HookName). Read-only.

Account root: balance, sequence, flags, regular key. Read-only.

Trustlines (issued-currency balances) held by an account. Read-only.

Ledger objects owned by an account, optionally filtered by type (hook, hook_state, uri_token, etc.). Read-only.

Open DEX offers placed by an account. Read-only.

URITokens (Xahau-native NFTs) owned by an account, with each token's URI decoded from hex to text. Read-only.

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.