Xahau MCP

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.

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.

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

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

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

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.

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

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

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

Current network transaction fee (base fee in drops + load/queue state) — for building a tx with the right Fee. Read-only.

Fetch a HookDefinition ledger object by hash (CreateCode WASM, HookOn, fee, reference count). Read-only.

Read Hook State entries for an account namespace (32-byte key→value map). Read-only.

Header/summary of a ledger (default the latest validated). Read-only.

A validated transaction by hash, including Xahau HookExecutions metadata (hook return codes/strings). Read-only.

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.

Look up a Hook API function: category, exit/guard role, and security hazard metadata. Offline.

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.

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.

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.

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.

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.

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.

Enumerate the Hook analyzer rule registry (id, severity, title, category). Offline.

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

Grade a Xahau account for quantum (HNDL) readiness: master-key-disabled, regular key, multi-sign and installed hooks → 0-100 score + tier + recommendations. Ports the xrpl-audit quantum model to Xahau, with a Hook/PQC dimension. Read-only.