# Xahau MCP (npm · xahau-mcp)

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

- Trust score: 74/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-23

## Components

- npm · `xahau-mcp`: 74/100 (this document), [markdown](https://verifymcp.io/servers/hugegreencandle-xahau-mcp/xahau-mcp.md), [page](https://verifymcp.io/servers/hugegreencandle-xahau-mcp/xahau-mcp)

## Channel facts

- Registry: `npm`
- Package: `xahau-mcp`
- Version: `2.3.0`
- 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-10-23.

- **Supply Chain Security**: 80/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known high-severity CVE affects @modelcontextprotocol/sdk 1.29.0, a direct dependency. A fixed version is available.
  - No install/post-install scripts declared.
  - 83 of 197 dependencies flagged as unhealthy (1 deprecated).
- **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 1 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 84/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 9206 tokens (~102/item across 90 items; 87 tools + 3 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 77/100
  - Stability observed for 23 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 80/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 31% of tool parameters carry a description.
  - Structured output schemas are declared (32% of tools); any adoption earns full credit.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "execute_hook" implies "execute" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 88 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Xahau MCP server?

Xahau MCP runs locally as an npm package, launched with npx -y xahau-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add hugegreencandle-xahau-mcp -- npx -y xahau-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "hugegreencandle-xahau-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "xahau-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "hugegreencandle-xahau-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "xahau-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add hugegreencandle-xahau-mcp -- npx -y xahau-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "hugegreencandle-xahau-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "xahau-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add hugegreencandle-xahau-mcp --command npx --arg -y --arg xahau-mcp
```

### Hermes

```yaml
mcp_servers:
  hugegreencandle-xahau-mcp:
    command: "npx"
    args: ["-y", "xahau-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "hugegreencandle-xahau-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "xahau-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add hugegreencandle-xahau-mcp -t stdio -c npx -a -y xahau-mcp
```

### Other

```json
{
  "mcpServers": {
    "hugegreencandle-xahau-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "xahau-mcp"
      ]
    }
  }
}
```

## 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-10-23 (score 74, +1)

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

### 2026-10-21 (score 73, +1)

- [security regression] CVE-2026-111768 affects this package: high
- [security regression] CVE-2026-111769 affects this package: high
- [security regression] CVE-2026-111767 affects this package: high
- [security regression] CVE-2026-111771 affects this package: high

### 2026-10-19 (score 72, +1)

- [functional regression] Security disclosure: unverified → fail

### 2026-10-18 (score 71, 0)

- [functional regression] Security disclosure: fail → unverified

### 2026-10-17 (score 71, +1)

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

### 2026-10-14 (score 70, +1)

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

### 2026-10-12 (score 69, −2)

- [security regression] CVE-2026-104850 affects this package: high
- [security regression] Known CVEs: partial → fail
- [security improvement] CVE-2025-14505 no longer affects this package

### 2026-10-05 (score 71, +1)

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

## MCP tools (87)

### `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` (~65 tokens)

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.

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_hook_can_emit` (~108 tokens)

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.

Input parameters:

- `hookCanEmit` (string, required): HookCanEmit hex (up to 64 chars)

### `encode_hook_can_emit` (~74 tokens)

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.

Input parameters:

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

### `estimate_hook_state_cost` (~146 tokens)

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.

Input parameters:

- `entries` (array, required)
- `ownerReserveIncrementXah` (number): optional: your network's owner-reserve increment in XAH, to convert units → XAH
- `scale` (integer)

### `simulate_hook_trigger` (~115 tokens)

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.

Input parameters:

- `tx` (object, required): transaction JSON (needs at least TransactionType + Account)

### `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` (~91 tokens)

Run the Hook static-analysis / security rule engine over a CreateCode WASM (+ optional SetHook params) and return SARIF-lite findings. 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` (~298 tokens)

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

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`

### `trace_transaction_stakeholders` (~97 tokens)

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.

Input parameters:

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

Output parameters:

- `error` (string)
- `metaPresent` (boolean)
- `network` (string)
- `note` (string)
- `originator`
- `stakeholderCount` (number)
- `stakeholders` (array)
- `summary` (string)
- `txHash` (string)

### `verify_double_threading` (~96 tokens)

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.

Input parameters:

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

Output parameters:

- `affectedNodeCount` (number)
- `anomalies` (array)
- `caveat` (string)
- `consistent` (boolean)
- `entries` (array)
- `error` (string)
- `network` (string)
- `summary` (string)
- `txHash`
- `uniqueLedgerObjects` (number)

### `audit_account_remarks` (~107 tokens)

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.

Input parameters:

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

Output parameters:

- `account` (string)
- `error` (string)
- `immutableCount` (number)
- `network` (string)
- `note` (string)
- `objects` (array)
- `objectsScanned` (number)
- `objectsWithRemarks` (number)
- `pagesFetched` (number)
- `remarkCount` (number)
- `summary` (string)
- `truncated` (boolean)

### `simulate_transaction` (~250 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), 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).

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)
- `transactor`
- `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)
- `transactor`
- `verdict` (string)

### `quantum_grade` (~129 tokens)

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, formally proven quantum-policy hook; mere hook presence is never scored. Read-only.

Input parameters:

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

Output parameters:

- `address` (string)
- `error` (string)
- `framing` (string)
- `hasProvenQuantumHook` (boolean)
- `hookPolicyNote` (string)
- `hooks`
- `masterDisabled` (boolean)
- `provenHook`
- `recommendations` (array)
- `regularKey`
- `score` (number)
- `signerList`
- `tier` (string)
- `tierLabel` (string)

### `quantum_config_census` (~140 tokens)

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.

Input parameters:

- `delayMs` (integer)
- `maxPages` (integer)
- `network` (string)
- `pageLimit` (integer)

Output parameters:

- `accounts` (number)
- `asOfComplete` (boolean)
- `caveat` (string)
- `error` (string)
- `hasRegularKeyCount` (number)
- `hasRegularKeyPct` (number)
- `masterDisabledCount` (number)
- `masterDisabledDrops` (string)
- `masterDisabledPct` (number)
- `masterDisabledSupplyPct` (number)
- `network` (string)
- `noRotationCount` (number)
- `noRotationDrops` (string)
- `noRotationPct` (number)
- `noRotationSupplyPct` (number)
- `pagesScanned` (number)
- `totalDrops` (string)

### `quantum_scorecard` (~181 tokens)

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.

Input parameters:

- `accounts` (array): explicit account list; omit to sample recently-active accounts
- `cap` (integer)
- `markdown` (boolean)
- `maxPages` (integer)
- `network` (string)
- `sampleLedgers` (integer)

Output parameters:

- `attempted` (number)
- `balanceAtRiskDrops` (string)
- `byExposureClass`
- `byGradeTier`
- `caveat` (string)
- `conclusiveCount` (number)
- `error` (string)
- `exposedCount` (number)
- `exposedPct` (number)
- `markdown` (string)
- `masterExposedBalanceDrops` (string)
- `masterExposedCount` (number)
- `masterExposedPct` (number)
- `network` (string)
- `originatorSample` (boolean)
- `population` (string)
- `provenQuantumHookCount` (number)
- `rows`
- `sampled` (number)
- `skipped` (number)
- `topExposedByBalance`
- `totalBalanceDrops` (string)
- `unknownCount` (number)

### `hndl_exposure` (~163 tokens)

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.

Input parameters:

- `address` (string, required): r-address
- `maxPages` (integer): history pages to scan (default 6 × 400 tx)
- `network` (string)

Output parameters:

- `accountId` (string)
- `address` (string)
- `balanceAtRiskDrops` (string)
- `balanceDrops` (string)
- `conclusive` (boolean)
- `error` (string)
- `exposed` (boolean)
- `exposureClass` (string)
- `firstExposureLedger`
- `masterDisabled` (boolean)
- `masterExposed` (boolean)
- `multisigExposed` (boolean)
- `network` (string)
- `note` (string)
- `recoverable`
- `regularExposed` (boolean)
- `scanned`
- `severity` (string)
- `signedTxCount` (number)

### `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)

### `get_amendment_status` (~82 tokens)

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.

Input parameters:

- `network` (string)

Output parameters:

- `caveat` (string)
- `enabled` (array)
- `enabledCount` (number)
- `error` (string)
- `knownNameTableSize` (number)
- `namedCount` (number)
- `network` (string)
- `summary` (string)
- `unnamedCount` (number)
- `voting` (array)
- `votingCount` (number)

### `predict_amendment_activation` (~85 tokens)

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.

Input parameters:

- `network` (string)

Output parameters:

- `caveat` (string)
- `error` (string)
- `majorityWindowDays` (number)
- `network` (string)
- `pending` (array)
- `pendingCount` (number)
- `summary` (string)

### `check_amendment_blocked` (~88 tokens)

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.

Input parameters:

- `network` (string)

Output parameters:

- `amendmentBlocked` (boolean)
- `buildVersion` (string)
- `error` (string)
- `network` (string)
- `networkId`
- `note` (string)
- `remedy` (string)
- `summary` (string)
- `validatedLedger`

### `diff_node_amendments` (~82 tokens)

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.

Input parameters:

- `a` (string)
- `b` (string)

Output parameters:

- `a` (string)
- `b` (string)
- `enabledA` (number)
- `enabledB` (number)
- `error` (string)
- `onlyOnA` (array)
- `onlyOnB` (array)
- `summary` (string)

### `build_sethook_unsigned` (~187 tokens)

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.

Input parameters:

- `account` (string, required)
- `createCodeHex` (string)
- `flags` (number)
- `grants` (array)
- `hookOn` (string)
- `namespace` (string, required): 32-byte HookNamespace hex
- `network` (string)
- `overrideCritical` (boolean): Build the tx even when preflight finds CRITICAL issues. Default false: the tx is withheld.
- `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_set_regular_key_unsigned` (~124 tokens)

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.

Input parameters:

- `account` (string, required)
- `network` (string)
- `regularKey` (string): new regular key r-address; omit to REMOVE

### `master_pubkey` (~95 tokens)

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.

Input parameters:

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

### `disable_master_readiness` (~93 tokens)

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.

Input parameters:

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

### `build_disable_master_unsigned` (~99 tokens)

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.

Input parameters:

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

### `build_signer_list_set_unsigned` (~104 tokens)

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.

Input parameters:

- `account` (string, required)
- `network` (string)
- `quorum` (integer, required)
- `signers` (array)

### `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)

### `build_remit_unsigned` (~264 tokens)

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.

Input parameters:

- `account` (string, required)
- `amounts` (array): currencies to send; each becomes an AmountEntry
- `blob` (string): arbitrary hex payload
- `destination` (string, required)
- `destinationTag` (number)
- `inform` (string): third-party account to notify (weak TSH; its hook runs)
- `invoiceId` (string): 64-hex InvoiceID
- `mintURIToken` (object): mint a new URIToken to the destination (e.g. a receipt)
- `network` (string)
- `uriTokenIds` (array): existing URIToken IDs (64-hex) to transfer to destination

### `build_set_remarks_unsigned` (~190 tokens)

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.

Input parameters:

- `account` (string, required)
- `network` (string)
- `objectId` (string, required): 64-hex ledger object ID to annotate (AccountRoot, URIToken, Offer, Escrow, trustline, …)
- `remarks` (array, required)

### `build_clawback_unsigned` (~159 tokens)

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.

Input parameters:

- `account` (string, required): the token issuer (you)
- `currency` (string, required): 3-char ISO code or 40-hex currency
- `holder` (string, required): the account to claw tokens back from
- `network` (string)
- `value` (string, required): amount to claw back (positive)

### `build_deepfreeze_unsigned` (~161 tokens)

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.

Input parameters:

- `account` (string, required): the issuer (you)
- `action` (string)
- `counterparty` (string, required): the holder side of the trustline
- `currency` (string, required): 3-char ISO code or 40-hex currency (issued, not XAH)
- `limitValue` (string): your existing trust limit to preserve (defaults to "0")
- `network` (string)

### `build_cronset_unsigned` (~212 tokens)

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.

Input parameters:

- `account` (string, required)
- `cancel` (boolean): tfCronUnset — remove the account's Cron
- `delaySeconds` (number): seconds between repeats
- `network` (string)
- `repeatCount` (number): 0–256 total repeats; omit for one-off
- `startInSeconds` (number): convenience: schedule for now + N seconds
- `startTime` (number): Ripple-epoch seconds; 0 = ASAP

### `list_cron_jobs` (~71 tokens)

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.

Input parameters:

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

### `monitor_cron_health` (~85 tokens)

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.

Input parameters:

- `account` (string, required)
- `lowThreshold` (number): warn when remaining repeats ≤ this
- `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, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/hugegreencandle-xahau-mcp/xahau-mcp#diagnostics

## Score history

- 2026-10-23: 74
- 2026-10-22: 73
- 2026-10-21: 73
- 2026-10-20: 72
- 2026-10-19: 72
- 2026-10-18: 71
- 2026-10-17: 71
- 2026-10-16: 70
- 2026-10-15: 70
- 2026-10-14: 70
- 2026-10-13: 69
- 2026-10-12: 69
- 2026-10-05: 71
- 2026-10-04: 70
- 2026-10-03: 68
- 2026-10-02: 68
- 2026-10-01: 68
- 2026-09-30: 43

## Common questions

### What is the Xahau MCP server?

Xahau MCP is listed in the public MCP registry as io.github.Hugegreencandle/xahau-mcp. MCP server for the Xahau network, offline Hook WASM VM + static analyzer, read-only ledger tools. This page covers its npm package (xahau-mcp).

### Is the Xahau MCP server safe to use?

Xahau MCP scores 74 out of 100 on VerifyMCP. We recorded 6 known advisories against it as of 23 October 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Xahau MCP server expose?

Xahau MCP exposes 87 tools: xahau_server_info, get_account_info, get_account_objects, get_account_hooks, get_hook_definition, and 82 more. Their descriptions and schemas cost roughly 9,127 tokens of context every time the server is loaded.

### Is the Xahau MCP server still maintained?

Xahau MCP is still listed as active in the MCP registry. We last reached this channel on 23 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Xahau MCP server under?

Xahau MCP declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/xahau-mcp
- Socket report: https://socket.dev/npm/package/xahau-mcp
- Repository: https://github.com/Hugegreencandle/xahau-mcp
- Changelog RSS feed: https://verifymcp.io/servers/hugegreencandle-xahau-mcp/xahau-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/hugegreencandle-xahau-mcp/xahau-mcp.json
- HTML version of this page: https://verifymcp.io/servers/hugegreencandle-xahau-mcp/xahau-mcp