# Xahau MCP (mcpb · xahau-mcp-2.0.1.mcpb)

First MCP for the Xahau network — offline Hook WASM VM + static analyzer, read-only ledger tools.

- Trust score: 44/100 (low)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- mcpb · `xahau-mcp-2.0.1.mcpb`: 44/100 (this document), [markdown](https://verifymcp.io/servers/hugegreencandle-xahau-mcp/https-github-com-hugegreencandle-xahau-mcp-releases-download-v2-0-1-xahau-mcp-2.md), [page](https://verifymcp.io/servers/hugegreencandle-xahau-mcp/https-github-com-hugegreencandle-xahau-mcp-releases-download-v2-0-1-xahau-mcp-2)

## Channel facts

- Registry: `mcpb`
- Package: `https://github.com/Hugegreencandle/xahau-mcp/releases/download/v2.0.1/xahau-mcp-2.0.1.mcpb`
- Version: `2.0.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 13/100
  - Malware scan not yet available for this package.
  - CVE data not yet available for this package.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (197 of 198), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 52 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 70/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (fair).
  - Tool/resource definitions use about 5839 tokens (~91/item across 64 items; 61 tools + 3 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 79/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 28% of tool parameters carry a description.
  - Structured output schemas are declared (30% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

- Download bundle: `https://github.com/Hugegreencandle/xahau-mcp/releases/download/v2.0.1/xahau-mcp-2.0.1.mcpb`

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 44, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-02 (score 43, +29)

- [functional regression] Dependency health: partial → unverified
- [functional improvement] Stability: unverified → 0.23
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Schema quality: unverified → fair
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100

### 2026-08-01 (score 14, −2)

- [functional regression] Security disclosure: unverified → fail

### 2026-07-31 (score 16, −2)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 18, +11)

- [security regression] Provenance: unverified → fail
- [security improvement] Install scripts: unverified → pass
- [functional improvement] License: unverified → pass
- [functional] Licence: MIT

### 2026-07-29 (score 7, −34)

- [security regression] Provenance: fail → unverified
- [security regression] Install scripts: pass → unverified
- [functional regression] Maintenance: pass → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] License: pass → unverified
- [functional regression] Security disclosure: fail → unverified
- [functional improvement] Dependency health: unverified → partial
- [functional] Licence: MIT

### 2026-07-27 (score 41)

First indexed and scored.

## MCP tools (61)

### `xahau_server_info` (~42 tokens)

Health, version, amendments and ledger range of a Xahau node (mainnet or testnet). Read-only.

Input parameters:

- `network` (string)

### `get_account_info` (~40 tokens)

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

Input parameters:

- `address` (string, required): r-address
- `network` (string)

### `get_account_objects` (~55 tokens)

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

Input parameters:

- `address` (string, required)
- `network` (string)
- `type` (string)

### `get_account_hooks` (~47 tokens)

The Hooks installed on an account, with each HookOn bitmap decoded to the transaction types it fires on. Read-only.

Input parameters:

- `address` (string, required)
- `network` (string)

### `get_hook_definition` (~49 tokens)

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

Input parameters:

- `hookHash` (string, required)
- `network` (string)

### `get_hook_state` (~55 tokens)

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

Input parameters:

- `address` (string, required)
- `namespace` (string, required): 32-byte HookNamespace hex
- `network` (string)

### `get_transaction` (~47 tokens)

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

Input parameters:

- `network` (string)
- `txHash` (string, required)

### `get_ledger` (~37 tokens)

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

Input parameters:

- `ledgerIndex`
- `network` (string)

### `get_fee` (~43 tokens)

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

Input parameters:

- `network` (string)

### `get_account_lines` (~39 tokens)

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

Input parameters:

- `address` (string, required)
- `network` (string)

### `get_account_offers` (~36 tokens)

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

Input parameters:

- `address` (string, required)
- `network` (string)

### `explain_account` (~90 tokens)

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

Input parameters:

- `address` (string, required): r-address
- `network` (string)

### `get_account_uritokens` (~54 tokens)

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

Input parameters:

- `address` (string, required)
- `network` (string)

### `decode_hook_on` (~62 tokens)

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.

Input parameters:

- `hookOn` (string, required): HookOn hex (up to 64 chars)

Output parameters:

- `count` (number)
- `error` (string)
- `firesOn` (array)
- `hookOn` (string)

### `encode_hook_on` (~42 tokens)

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

Input parameters:

- `txTypes` (array, required): e.g. ["Payment","Invoke"]

Output parameters:

- `error` (string)
- `firesOn` (array)
- `hookOn` (string)

### `decode_sethook` (~49 tokens)

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

Input parameters:

- `tx` (object)
- `txBlobHex` (string)

### `decode_tx_blob` (~41 tokens)

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

Input parameters:

- `txBlobHex` (string, required)

### `encode_tx_blob` (~41 tokens)

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

Input parameters:

- `tx` (object, required)

### `decode_uritoken_id` (~46 tokens)

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

Input parameters:

- `uriTokenId` (string, required)

### `xah_amount` (~42 tokens)

Convert between XAH and drops (1 XAH = 1,000,000 drops). Offline.

Input parameters:

- `from` (string, required)
- `value` (required)

### `validate_address` (~46 tokens)

Validate a Xahau/XRPL address (classic r-address or X-address) → type, account-id, embedded destination tag, network. Offline.

Input parameters:

- `address` (string, required)

Output parameters:

- `accountId` (string)
- `classicAddress` (string)
- `error` (string)
- `network` (string)
- `reason` (string)
- `tag`
- `type` (string)
- `valid` (boolean)

### `xaddress` (~67 tokens)

Encode a classic address + destination tag into an X-address, or decode an X-address back to classic + tag. Offline.

Input parameters:

- `address` (string, required): classic r-address (to encode) or X-address (to decode)
- `tag` (number)
- `test` (boolean)

### `currency_code` (~64 tokens)

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.

Input parameters:

- `input` (string, required): a 3-char code or a 40-hex currency

### `decode_result` (~61 tokens)

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

Input parameters:

- `result` (required): a result code number or name

### `ripple_time` (~66 tokens)

Convert between Ripple time (seconds since 2000-01-01), Unix time, and ISO 8601. Xahau tx/ledger timestamps use Ripple time. Offline.

Input parameters:

- `iso` (string)
- `ripple` (number)
- `unix` (number)

### `decode_xpop` (~107 tokens)

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.

Input parameters:

- `xpop` (required): Import Blob hex, XPOP JSON string, or XPOP object

Output parameters:

- `burnedDrops`
- `error` (string)
- `innerTransaction`
- `innerTransactionType`
- `ledger`
- `ledgerIndex`
- `metaPresent` (boolean)
- `proofPresent` (boolean)
- `summary` (string)
- `targetNetworkId`
- `validators`
- `warnings` (array)

### `inspect_emitted_tx` (~90 tokens)

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.

Input parameters:

- `emitted` (array, required): emitted blob hex(es) from execute_hook's `emitted` array

### `decode_lease_uri` (~114 tokens)

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.

Input parameters:

- `uri` (string, required): URIToken.URI hex, base64 text, or raw lease-buffer hex

### `decode_amount` (~69 tokens)

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.

Input parameters:

- `amount` (required): drops string, STAmount hex, or amount object

Output parameters:

- `currency`
- `drops` (string)
- `error` (string)
- `issuer`
- `type` (string)
- `value`
- `valueNote` (string)
- `xah` (string)

### `decode_sign_request` (~92 tokens)

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.

Input parameters:

- `txBlobHex` (string)
- `txjson` (object)

Output parameters:

- `amountDecoded`
- `error` (string)
- `summary` (string)
- `transactionType`
- `tx` (object)
- `warnings` (array)

### `scam_check` (~166 tokens)

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.

Input parameters:

- `txBlobHex` (string)
- `txjson` (object)

### `inspect_hook_wasm` (~73 tokens)

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.

Input parameters:

- `wasmBase64` (string)
- `wasmHex` (string)

### `analyze_hook` (~101 tokens)

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.

Input parameters:

- `flags` (number)
- `grants` (array)
- `hookOn` (string)
- `namespace` (string)
- `parameters` (array)
- `wasmBase64` (string)
- `wasmHex` (string)

Output parameters:

- `decoded` (object)
- `error` (string)
- `findings` (array)
- `summary` (object)
- `valid` (boolean)

### `audit_account_hooks` (~54 tokens)

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

Input parameters:

- `address` (string, required)
- `network` (string)

### `list_rules` (~26 tokens)

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

### `hook_dry_run` (~93 tokens)

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.

Input parameters:

- `candidateTxType` (string, required): e.g. "Payment"
- `hookOn` (string, required)
- `wasmBase64` (string)
- `wasmHex` (string)

### `execute_hook` (~312 tokens)

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

Input parameters:

- `feeBase` (number)
- `hookAccountId` (string): 20-byte account-id hex the hook is installed on
- `hookParams` (object)
- `keyletBlobs` (object): 32-byte ledger index hex -> serialized object hex, for slot_set
- `ledgerSeq` (number)
- `network` (string)
- `otxnBlob` (string): full originating-txn serialized blob hex (enables otxn_slot)
- `otxnFields` (object): field-id -> hex value of originating-txn fields the hook reads
- `otxnParams` (object): otxn param name -> hex value
- `resolveKeylets` (boolean): if true, fetch any slot_set'd ledger objects live and re-run (async pre-resolve)
- `state` (object): initial hook state: 32-byte key hex -> value hex
- `txType` (string): originating tx type, e.g. "Payment"
- `wasmBase64` (string)
- `wasmHex` (string)

Output parameters:

- `caveat` (string)
- `degraded` (boolean)
- `emitted` (array)
- `error` (string)
- `exit` (string)
- `fidelity` (string)
- `foreignStateWrites` (array)
- `resolvedForeignState` (array)
- `resolvedKeylets` (array)
- `returnCode`
- `returnString` (string)
- `stateApplied`
- `stateWrites` (array)
- `syntheticCalls` (array)
- `trace` (array)
- `unsupportedCalls` (array)
- `wantedForeignState` (array)
- `wantedKeylets` (array)

### `annotate_hook_trace` (~190 tokens)

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.

Input parameters:

- `trace` (array, required): trace[] from an execute_hook result; each element "label: HEXVALUE"

### `fuzz_hook` (~401 tokens)

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.

Input parameters:

- `amountField` (number): otxn field id to write the Amount sweep into (default 6)
- `amountMax` (number): Amount axis high (raw drops)
- `amountMin` (number): Amount axis low (raw drops; field bytes are NOT STAmount-encoded)
- `feeBase` (number)
- `hookAccountId` (string)
- `hookParams` (object)
- `ledgerSeq` (number)
- `otxnFields` (object)
- `otxnParams` (object)
- `paramSweep` (object): named otxn params -> candidate hex values to sweep
- `samples` (number): number of generated inputs (default 64, max 512)
- `state` (object)
- `sweepAccount` (boolean): also sweep a few deterministic account ids
- `sweepDestination` (boolean): also sweep a few deterministic destination ids
- `txType` (string): base originating tx type
- `txTypes` (array): txType axis: tx types to sweep, e.g. ["Payment","Invoke"]. Default: all known tx types (capped).
- `wasmBase64` (string)
- `wasmHex` (string)

### `estimate_hook_fee` (~83 tokens)

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.

Input parameters:

- `wasmBase64` (string)
- `wasmHex` (string)

### `hook_report` (~108 tokens)

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.

Input parameters:

- `grants` (array)
- `hookOn` (string)
- `namespace` (string)
- `wasmBase64` (string)
- `wasmHex` (string)

Output parameters:

- `analysis` (object)
- `classification` (object)
- `error` (string)
- `feeEstimate` (object)
- `hookOnDecoded`
- `structure` (object)
- `verdict` (string)

### `scaffold_hook` (~127 tokens)

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.

Input parameters:

- `archetype` (string, required)
- `blockTxType` (string): for firewall: tx type to reject, e.g. Payment
- `maxDrops` (string): for payment_limit: max native drops to allow

### `classify_hook` (~97 tokens)

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.

Input parameters:

- `hookOn` (string)
- `wasmBase64` (string)
- `wasmHex` (string)

Output parameters:

- `archetype` (string)
- `behaviors` (array)
- `capabilities` (array)
- `confidence` (string)
- `error` (string)
- `firesOn`
- `summary` (string)
- `valid` (boolean)

### `hook_diff` (~119 tokens)

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.

Input parameters:

- `afterHookOn` (string)
- `afterWasmBase64` (string)
- `afterWasmHex` (string)
- `beforeHookOn` (string)
- `beforeWasmBase64` (string)
- `beforeWasmHex` (string)

Output parameters:

- `byteSizeAfter` (number)
- `byteSizeBefore` (number)
- `byteSizeDelta` (number)
- `error` (string)
- `exports` (object)
- `firesOn`
- `guardDelta` (number)
- `imports` (object)
- `instructionDelta` (number)
- `loopDelta` (number)
- `newSensitiveCapabilities` (array)
- `summary` (string)

### `hook_api_lookup` (~51 tokens)

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

Input parameters:

- `name` (string, required): e.g. emit, state_set, _g, otxn_field

### `compute_reward` (~111 tokens)

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.

Input parameters:

- `address` (string)
- `balanceXAH` (number)
- `currentLedger` (number)
- `network` (string)
- `rewardAccumulator` (number)
- `rewardLgrFirst` (number)

### `reward_status` (~130 tokens)

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.

Input parameters:

- `address` (string, required): r-address
- `network` (string)

Output parameters:

- `accrual`
- `address` (string)
- `balanceXah`
- `eligibility`
- `error` (string)
- `fields`
- `network` (string)
- `notes` (array)
- `optedIn` (boolean)
- `params` (object)
- `summary` (string)
- `unsignedTx`
- `unsignedTxPurpose`
- `warnings` (array)

### `evernode_host_diagnostics` (~129 tokens)

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

Input parameters:

- `address` (string, required): host r-address
- `network` (string)

Output parameters:

- `address` (string)
- `balances` (object)
- `checks` (array)
- `error` (string)
- `heartbeat`
- `isRegisteredHost` (boolean)
- `leases` (object)
- `network` (string)
- `notes` (array)
- `registration`
- `specs`
- `summary` (string)
- `warnings` (array)

### `diagnose_failed_tx` (~152 tokens)

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

Input parameters:

- `network` (string)
- `txHash` (string, required): transaction hash

Output parameters:

- `causes` (array)
- `engineResult`
- `engineResultCode`
- `error` (string)
- `failed`
- `fixes` (array)
- `found` (boolean)
- `hookRejections` (array)
- `network` (string)
- `notes` (array)
- `partialDelivery`
- `resultClass`
- `summary` (string)
- `txHash` (string)
- `validated`
- `whatItTried`

### `simulate_transaction` (~195 tokens)

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), and a scam score. Never signs, never submits. Slow but thorough (iterative state resolution, ~1.1s per read).

Input parameters:

- `network` (string)
- `tx` (object, required): unsigned transaction JSON (TransactionType, Account, ...)

Output parameters:

- `baseTxHash` (string)
- `caveat` (string)
- `error` (string)
- `historical` (boolean)
- `hookRuns` (array)
- `ledgerIndex` (number)
- `notes` (array)
- `overriddenFields` (array)
- `scamScore`
- `staticChecks` (array)
- `summary` (string)
- `verdict` (string)

### `what_if` (~134 tokens)

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.

Input parameters:

- `network` (string)
- `overrides` (object): fields to change on the tx before re-simulating (e.g. {"Amount": "99000000"})
- `txHash` (string, required): real validated transaction hash

Output parameters:

- `baseTxHash` (string)
- `caveat` (string)
- `error` (string)
- `historical` (boolean)
- `hookRuns` (array)
- `ledgerIndex` (number)
- `notes` (array)
- `overriddenFields` (array)
- `scamScore`
- `staticChecks` (array)
- `summary` (string)
- `verdict` (string)

### `quantum_grade` (~85 tokens)

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.

Input parameters:

- `address` (string, required): r-address
- `network` (string)

Output parameters:

- `address` (string)
- `error` (string)
- `hooks`
- `masterDisabled` (boolean)
- `recommendations` (array)
- `regularKey`
- `score` (number)
- `signerList`
- `tier` (string)

### `governance_state` (~115 tokens)

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.

Input parameters:

- `network` (string)

### `decode_b2m` (~40 tokens)

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

Input parameters:

- `tx` (object, required)

### `build_sethook_unsigned` (~134 tokens)

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.

Input parameters:

- `account` (string, required)
- `createCodeHex` (string)
- `flags` (number)
- `grants` (array)
- `hookOn` (string)
- `namespace` (string, required): 32-byte HookNamespace hex
- `network` (string)
- `parameters` (array)
- `txTypes` (array)
- `wasmHex` (string)

### `build_claimreward_unsigned` (~55 tokens)

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

Input parameters:

- `account` (string, required)
- `issuer` (string)
- `network` (string)

### `build_import_unsigned` (~78 tokens)

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.

Input parameters:

- `account` (string, required)
- `network` (string)
- `xpopBlobHex` (string, required): HEX-encoded XPOP proof

### `build_payment_unsigned` (~106 tokens)

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

Input parameters:

- `account` (string, required)
- `amountDrops` (string, required): native amount in DROPS (1 XAH = 1,000,000 drops); use xah_amount to convert XAH→drops
- `destination` (string, required)
- `destinationTag` (number)
- `network` (string)

### `prepare_transaction` (~136 tokens)

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

Input parameters:

- `lastLedgerOffset` (number)
- `network` (string)
- `tx` (object, required): unsigned tx JSON; must include Account + TransactionType

### `vm_fidelity_report` (~184 tokens)

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.

Input parameters:

- `includeMismatches` (boolean): include the per-mismatch list (txHash/vmExit/onChainResult)

Output parameters:

- `agreementPct`
- `agreements` (number)
- `comparable` (number)
- `composition`
- `coverageWarning`
- `degradedCount` (number)
- `error` (string)
- `headline` (string)
- `insufficient` (boolean)
- `mismatches` (array)
- `perHook` (array)
- `total` (number)

### `hook_execution_postmortem` (~242 tokens)

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.

Input parameters:

- `network` (string)
- `txHash` (string, required): Xahau tx hash of the transaction to post-mortem

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/hugegreencandle-xahau-mcp/https-github-com-hugegreencandle-xahau-mcp-releases-download-v2-0-1-xahau-mcp-2#diagnostics

## Score history

- 2026-08-03: 44
- 2026-08-02: 43
- 2026-08-01: 14
- 2026-07-31: 16
- 2026-07-30: 18
- 2026-07-29: 7
- 2026-07-28: 41
- 2026-07-27: 41

## Links

- Repository: https://github.com/Hugegreencandle/xahau-mcp
- Changelog RSS feed: https://verifymcp.io/servers/hugegreencandle-xahau-mcp/https-github-com-hugegreencandle-xahau-mcp-releases-download-v2-0-1-xahau-mcp-2/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/hugegreencandle-xahau-mcp/https-github-com-hugegreencandle-xahau-mcp-releases-download-v2-0-1-xahau-mcp-2/changelog.json
- HTML version of this page: https://verifymcp.io/servers/hugegreencandle-xahau-mcp/https-github-com-hugegreencandle-xahau-mcp-releases-download-v2-0-1-xahau-mcp-2