DERO MCP Server

Official33 toolsLive

by DHEBP · TypeScript

Read-only DERO blockchain MCP: 33 tools (12 composites) incl. TELA discovery + bundled docs.

io.github.DHEBP/dero-mcp-server: Model Context Protocol Server

This is a read-only Model Context Protocol (MCP) server for the DERO privacy blockchain. It exposes 33 tools, including 12 composite tools, built on 21 daemon primitives. The server supports TELA discovery and includes a bundled documentation index spanning derod, tela, hologram, and deropay.

🛠️ Key Features

Read-only MCP server for DERO
33 total tools (12 composites)
21 daemon primitives
Includes TELA on-chain app inspection and dURL→SCID discovery
Bundled documentation index for derod, tela, hologram, and deropay

🚀 Use Cases

Discover and inspect DERO/TELA on-chain application details
Convert dURL inputs to SCID for DERO discovery workflows
Use DERO daemon primitives for read-only blockchain context

⚡ Developer Benefits

Centralized access to DERO-related tooling via MCP
Composite tools for higher-level discovery tasks
Documentation bundling across derod, tela, hologram, and deropay

⚠️ Limitations

Read-only: no capability to perform state-changing blockchain actions beyond exposed daemon/composite operations

Topics

blockchaincryptocurrencyprivacy

Captured live from the server via tools/list.

dero_daemon_ping

DERO daemon connectivity check via DERO.Ping. When to call: as the first step in any chain investigation to confirm the daemon is reachable. Call before dero_get_info if you are unsure whether DERO_DAEMON_URL is correctly configured. Input Requirements: none. Output: a "Pong" string when the daemon is healthy. On failure this tool returns a structured _meta.error with code RPC_UNREACHABLE and a retry hint.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

dero_daemon_echo

Echo strings through the daemon via DERO.Echo. Useful for round-trip sanity checks. When to call: when you need to confirm that string payloads reach the daemon intact (e.g. before debugging a malformed call to a more complex tool). PREFER dero_daemon_ping for a lighter-weight liveness probe. Input Requirements (CRITICAL): - `words` MUST be a non-empty array of strings. Output: the echoed string concatenated by the daemon.

Parameters1

words

array

required

Strings to echo back

Raw schema

{
  "type": "object",
  "properties": {
    "words": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Strings to echo back"
    }
  },
  "required": [
    "words"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_info

Get DERO daemon and chain metadata: height, topoheight, stableheight, difficulty, version, network, mempool size, and total supply (DERO.GetInfo). When to call: first thing in any chain-state investigation or sync-health check. Call this BEFORE dero_get_sc, dero_get_transaction, or dero_get_block when you do not already know the current tip. PREFER citing dero_docs_search("DERO.GetInfo") so the user can verify field semantics. Input Requirements: none. Output: full chain info JSON including `topoheight`, `stableheight`, `height`, `network`, `version`, `difficulty`, `tx_pool_size`, and `total_supply`.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

dero_get_height

Get the current block heights: tip height, stable height (finalized), and topoheight (canonical ordering) via DERO.GetHeight. When to call: when you need a quick height snapshot without the full chain-info payload. PREFER dero_get_info when you also need network, version, or difficulty. Input Requirements: none. Output: `{ height, stableheight, topoheight }`.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

dero_get_block_count

Get the total block count via DERO.GetBlockCount. This is a tip count, not a topoheight. When to call: when you need just the block count (e.g. for delta math against a reference height). PREFER dero_get_height when you need tip and stable heights together. Input Requirements: none. Output: `{ count }`.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

dero_get_last_block_header

Get the header of the current tip block via DERO.GetLastBlockHeader (no full block body). When to call: when you need tip block metadata (hash, miner, timestamp, difficulty) without the transactions or miner_tx payload. PREFER dero_get_block when you need transactions or the miner_tx. Input Requirements: none. Output: `{ block_header: { hash, height, topoheight, timestamp, difficulty, ... } }`.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

dero_get_block

Fetch a full block (header + miner_tx + transactions + topo position) by height OR hash via DERO.GetBlock. When to call: when investigating a specific block or verifying a transaction's inclusion. Call dero_get_height first if you do not have a target height. PREFER citing dero_docs_search("block structure") so the user can verify field semantics. Input Requirements (CRITICAL): - You MUST provide exactly ONE of `hash` or `height`. Providing both or neither returns a structured INVALID_INPUT error. - `hash` MUST be exactly 64 hex characters. - `height` MUST be a non-negative integer. Output: full block with `block_header`, `miner_tx`, `txs`, and topo position fields.

Parameters2

hash	string	optional	64-char hex block hash
height	integer	optional	Block height

Raw schema

{
  "type": "object",
  "properties": {
    "hash": {
      "description": "64-char hex block hash",
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$"
    },
    "height": {
      "description": "Block height",
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_block_header_by_topo_height

Get a block header by topological height (canonical ordering) via DERO.GetBlockHeaderByTopoHeight. When to call: when you need a header keyed by topo position rather than chain height. Topoheight is the canonical ordering used by DERO indexers; height is the consensus block height. Input Requirements (CRITICAL): - `topoheight` MUST be a non-negative integer no greater than the current topoheight (call dero_get_info first if unsure). Output: `{ block_header: { hash, height, topoheight, timestamp, ... } }`.

Parameters1

topoheight

integer

required

Topological height

Raw schema

{
  "type": "object",
  "properties": {
    "topoheight": {
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991,
      "description": "Topological height"
    }
  },
  "required": [
    "topoheight"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_block_header_by_hash

Get a block header by its 64-char hex hash via DERO.GetBlockHeaderByHash. When to call: when you have a block hash (e.g. from a tx confirmation) and need its header without the full block body. PREFER dero_get_block when you also need the txs or miner_tx. Input Requirements (CRITICAL): - `hash` MUST be exactly 64 hex characters (matches /^[0-9a-fA-F]{64}$/). Output: `{ block_header: {...} }`.

Parameters1

hash

string

required

Block top hash (hex)

Raw schema

{
  "type": "object",
  "properties": {
    "hash": {
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$",
      "description": "Block top hash (hex)"
    }
  },
  "required": [
    "hash"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_tx_pool

List pending mempool transaction hashes via DERO.GetTxPool. When to call: when checking unconfirmed activity, watching for a specific tx to land, or estimating mempool pressure. NOTE: `tx_hashes` may be `null` or an empty array when the mempool is empty — treat both as "no pending". Input Requirements: none. Output: `{ tx_hashes: string[] | null }`.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {}
}

dero_get_random_address

Get random registered addresses from the chain (used for ring construction in private transfers) via DERO.GetRandomAddress. When to call: when building a transfer ring in external wallet tooling, or sampling chain participants. Optional asset SCID limits sampling to holders of that asset. Input Requirements: - `scid` is OPTIONAL. When provided it MUST be exactly 64 hex characters. Output: `{ address: string[] }`.

Parameters1

scid

string

optional

Optional asset smart-contract id (hex)

Raw schema

{
  "type": "object",
  "properties": {
    "scid": {
      "description": "Optional asset smart-contract id (hex)",
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_transaction

Fetch one or more transactions by hash via DERO.GetTransaction. Each tx is returned with confirmation status, block hash, and (optionally) decoded JSON fields. When to call: when tracing a tx by hash. Pair with dero_get_sc when the tx invokes a contract. PREFER citing dero_docs_search("transaction structure") so the user can interpret confirmations, ring members, and SC fields. Input Requirements (CRITICAL): - `txs_hashes` MUST be a non-empty array of 64-char hex strings. - `decode_as_json` is OPTIONAL. PREFER `1` (any non-zero value) when you want JSON-decoded fields instead of raw blobs. Output: `{ txs: [...], txs_as_hex: [...] }` with per-tx confirmation, block hash, and (when decoded) parsed payload.

Parameters2

txs_hashes	array	required	List of transaction hashes (hex)
decode_as_json	integer	optional	Optional: decode each tx as JSON when non-zero

Raw schema

{
  "type": "object",
  "properties": {
    "txs_hashes": {
      "minItems": 1,
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^[0-9a-fA-F]{64}$"
      },
      "description": "List of transaction hashes (hex)"
    },
    "decode_as_json": {
      "description": "Optional: decode each tx as JSON when non-zero",
      "type": "integer",
      "minimum": -9007199254740991,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "txs_hashes"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_encrypted_balance

Get the ENCRYPTED balance blob for a DERO address at a topo height via DERO.GetEncryptedBalance. CRITICAL: this returns an opaque encrypted blob, NOT a cleartext balance. Only the wallet holding the spend key can decrypt it. Do NOT present the encrypted bytes as a balance to the user. When to call: when verifying that an address has on-chain encrypted state (e.g. before attempting a transfer with a wallet you control), or as a sub-step in another tool. PREFER citing dero_docs_search("encrypted balance") so the user understands the opacity. Input Requirements (CRITICAL): - `address` MUST start with `dero1` (mainnet) or `deto1` (testnet). - `topoheight` MUST be an integer; use `-1` for the latest chain tip. - `scid` is OPTIONAL. Omit for native DERO; provide 64-hex SCID for asset balances. Output: `{ status, registration, balance (encrypted blob), ... }`.

Parameters3

address	string	required	DERO address (dero1… or deto1…)
topoheight	integer	required	Use -1 for latest chain tip
scid	string	optional	Asset SCID hex; omit for native DERO

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "type": "string",
      "pattern": "^(dero1|deto1)[0-9a-z]+$",
      "description": "DERO address (dero1… or deto1…)"
    },
    "topoheight": {
      "type": "integer",
      "minimum": -9007199254740991,
      "maximum": 9007199254740991,
      "description": "Use -1 for latest chain tip"
    },
    "scid": {
      "description": "Asset SCID hex; omit for native DERO",
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$"
    }
  },
  "required": [
    "address",
    "topoheight"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_sc

Read smart contract state (code and/or stored variables) by SCID via DERO.GetSC. This is the primary entry point for any contract inspection on DERO. When to call: as the first step in any DVM contract investigation. Pair with dero_docs_search("DVM-BASIC") to interpret the returned code blob. PREFER citing dero_docs_search("smart contract") or dero_docs_get_page on a relevant DVM page so the user can interpret the contract's state model. Input Requirements (CRITICAL): - `scid` MUST be exactly 64 hex characters (the contract id). - `code` is OPTIONAL (defaults to true). Set false to skip the source blob when you only need stored variables. - `variables` is OPTIONAL (defaults to true). Set false to skip variables when you only need the source. - `topoheight` is OPTIONAL. Omit or use `-1` for the latest committed state. Output: `{ code, balances, variables: { stringkeys, uint64keys }, ... }`.

Parameters4

scid	string	required	64-char hex Smart Contract ID
code	boolean	optional	Include contract source (default true)
variables	boolean	optional	Include stored variables (default true)
topoheight	integer	optional	Topo height; omit or use -1 for latest

Raw schema

{
  "type": "object",
  "properties": {
    "scid": {
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$",
      "description": "64-char hex Smart Contract ID"
    },
    "code": {
      "description": "Include contract source (default true)",
      "type": "boolean"
    },
    "variables": {
      "description": "Include stored variables (default true)",
      "type": "boolean"
    },
    "topoheight": {
      "description": "Topo height; omit or use -1 for latest",
      "type": "integer",
      "minimum": -9007199254740991,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "scid"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_gas_estimate

Estimate gas (compute + storage) for transfers, SC deploys, or SC invokes via DERO.GetGasEstimate. This is a PRE-FLIGHT check; nothing is submitted. When to call: BEFORE any wallet-side transfer/scinvoke (using external wallet tooling) to size fees, OR when explaining deploy costs to a user. PREFER citing dero_docs_search("gas estimate" or "fees") so the user understands how compute vs storage gas are charged. Input Requirements (CRITICAL): - At least ONE of `transfers`, `sc`, or `sc_rpc` MUST be provided. - `sc` is the DVM-BASIC contract source string when estimating a deploy. - `sc_rpc` is an array of `{ name, datatype, value }` invocation arguments (entrypoint + SC_ID + caller-provided params). - `signer` is OPTIONAL but PREFERRED; pass the `dero1.../deto1...` address that would sign the eventual tx. Output: `{ gascompute, gasstorage, status }`.

Parameters4

transfers	array	optional	Optional transfer list
sc	string	optional	SC source to deploy
sc_rpc	array	optional	SC invocation arguments (entrypoint, SC_ID, etc.)
signer	string	optional	Signer address used for estimation

Raw schema

{
  "type": "object",
  "properties": {
    "transfers": {
      "description": "Optional transfer list",
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "sc": {
      "description": "SC source to deploy",
      "type": "string"
    },
    "sc_rpc": {
      "description": "SC invocation arguments (entrypoint, SC_ID, etc.)",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "datatype": {
            "type": "string",
            "enum": [
              "S",
              "U",
              "H"
            ]
          },
          "value": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "number"
              }
            ]
          }
        },
        "required": [
          "name",
          "datatype",
          "value"
        ]
      }
    },
    "signer": {
      "description": "Signer address used for estimation",
      "type": "string"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_name_to_address

Resolve a DERO on-chain registered name to its address via DERO.NameToAddress. When to call: when a user supplies a human-readable name (e.g. "myname") instead of a `dero1.../deto1...` address. Input Requirements (CRITICAL): - `name` MUST be a non-empty string. Resolution is case-sensitive on the daemon side. - `topoheight` MUST be an integer; use `-1` for the latest registry state. Output: `{ name, address }`. On NOT_FOUND the daemon's RPC error is surfaced as a structured _meta.error.

Parameters2

name	string	required	Registered name
topoheight	integer	required	Use -1 for latest

Raw schema

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "minLength": 1,
      "description": "Registered name"
    },
    "topoheight": {
      "type": "integer",
      "minimum": -9007199254740991,
      "maximum": 9007199254740991,
      "description": "Use -1 for latest"
    }
  },
  "required": [
    "name",
    "topoheight"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_get_block_template

Get a mining block template for a miner payout address via DERO.GetBlockTemplate. When to call: ONLY when you are actually mining. PREFER dero_get_last_block_header for general chain-tip inspection. Input Requirements (CRITICAL): - `wallet_address` MUST be a valid DERO address (`dero1...` or `deto1...`) that will receive the block reward. - `block` is OPTIONAL. Set true to include the raw block blob in the response. - `miner` is an OPTIONAL label. Output: block template payload suitable for a mining client. Does NOT submit a block; submission requires the excluded DERO.SubmitBlock method.

Parameters3

wallet_address	string	required	Miner payout DERO address
block	boolean	optional	Include block blob
miner	string	optional	Optional miner id / label

Raw schema

{
  "type": "object",
  "properties": {
    "wallet_address": {
      "type": "string",
      "pattern": "^(dero1|deto1)[0-9a-z]+$",
      "description": "Miner payout DERO address"
    },
    "block": {
      "description": "Include block blob",
      "type": "boolean"
    },
    "miner": {
      "description": "Optional miner id / label",
      "type": "string"
    }
  },
  "required": [
    "wallet_address"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_decode_proof_string

Decode any DERO bech32 string (`dero…`, `deto…`, `deroi…`, `detoi…`, or `deroproof…`) into its constituent parts: HRP, network, compressed public key, and any embedded RPC arguments (CBOR-encoded). For `deroproof…` strings the "public key" is a derived blinder point used in the proof's commitment math, NOT a wallet pubkey — the tool surfaces `is_proof: true` so the agent does not mislabel it. When to call: when the user pastes a `deroproof…` / integrated-address string and wants to know what value or fields it encodes. PREFER this over chaining bech32 decoders + CBOR libraries yourself: the tool implements the exact same wire format as DEROHE `rpc.NewAddress` and surfaces the `RPC_VALUE_TRANSFER` uint64 both as raw and as a signed/wraparound interpretation. The decoder is verified against the publicly-cited 2022 inflation-claim proof string (embedded uint64 = 18446743853709551435 = signed -2,200,000.00181 DERO). Input Requirements (CRITICAL): - `proof_string` is REQUIRED. The full bech32 string including HRP and separator (e.g. `deroproof1qyy…`). Whitespace is trimmed but the case must be consistent (all lower OR all upper per BIP-0173). Output: `{ decoded: { hrp, mainnet, is_proof, public_key_hex, arguments[] }, value_interpretation?: { uint64, signed_int64, is_negative_wraparound, signed_atoms, dero }, context_note?, related_docs? }`. `arguments` is an array of `{ name, type, type_label, semantic_name?, value }`. `value_interpretation` is present only when an `RPC_VALUE_TRANSFER` (V) + `uint64` (U) argument is found. `context_note` + extra `related_docs` are silently attached when the input matches a flagged adversarially-cited artifact. Returns a structured `_meta.error` with code `INVALID_BECH32` on parse failure. PREFER citing `integrity/payload-vs-transaction-proofs` and `integrity/negative-transfer-protection` in any agent response that frames a `deroproof…` decode result — readers should understand that "this string decodes to value V" is a display-layer fact, not a consensus statement.

Parameters1

proof_string

string

required

Full bech32 string with HRP, e.g. "deroproof1qyy…" or "dero1abc…". Whitespace is trimmed.

Raw schema

{
  "type": "object",
  "properties": {
    "proof_string": {
      "type": "string",
      "minLength": 8,
      "description": "Full bech32 string with HRP, e.g. \"deroproof1qyy…\" or \"dero1abc…\". Whitespace is trimmed."
    }
  },
  "required": [
    "proof_string"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_docs_search

Search the bundled DERO documentation index across derod, tela, hologram, and deropay (145+ pages). In-process — no network round trip. When to call: when you need authoritative docs to answer a DERO question, OR before constructing a citation in your response. Call this BEFORE explaining DVM, RPC methods, TELA contracts, Hologram simulator, or DeroPay webhooks. PREFER returning the top match's `canonical_url` and `slug` to the user as a citation. Input Requirements (CRITICAL): - `query` MUST be a non-empty search string. - `product` is OPTIONAL. Provide when you know the scope to reduce noise (e.g. `tela` for TELA-DOC-1 questions). - `section` is OPTIONAL. Provide a slug prefix to scope further (e.g. `rpc-api` under `product=derod`). - `limit` is OPTIONAL (default 8, max 25). Output: ranked matches with `title`, `slug`, `headings`, `excerpt`, `canonical_url`, and `score`.

Parameters4

query	string	required	Search text (e.g., "wallet rpc", "tela deployment", "deropay webhooks")
product	string	optional	Optional docs product filter: derod \| tela \| hologram \| deropay
section	string	optional	Optional section slug prefix (e.g., "rpc-api", "guides", "dero-pay")
limit	integer	optional	Max matches (default 8, max 25)

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "minLength": 1,
      "description": "Search text (e.g., \"wallet rpc\", \"tela deployment\", \"deropay webhooks\")"
    },
    "product": {
      "description": "Optional docs product filter: derod | tela | hologram | deropay",
      "type": "string",
      "enum": [
        "derod",
        "tela",
        "hologram",
        "deropay"
      ]
    },
    "section": {
      "description": "Optional section slug prefix (e.g., \"rpc-api\", \"guides\", \"dero-pay\")",
      "type": "string"
    },
    "limit": {
      "description": "Max matches (default 8, max 25)",
      "type": "integer",
      "minimum": 1,
      "maximum": 25
    }
  },
  "required": [
    "query"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_docs_get_page

Get a single bundled docs page by slug, with plain-text content and headings. When to call: AFTER dero_docs_search has returned a candidate slug, OR when you have a known slug from a prior citation. PREFER dero_docs_search first when you only have a topic in mind. Input Requirements (CRITICAL): - `slug` MUST be a non-empty doc slug relative to pages/ (e.g. `rpc-api/daemon-rpc-api`, `tutorials/first-app`, `dero-pay/quick-start`). - `product` is OPTIONAL but RECOMMENDED to disambiguate identical slugs across docs sites (`derod`, `tela`, `hologram`, `deropay`). - `offset` is OPTIONAL. Long pages (the Captain archive, deep RPC references) are returned in 60000-char chunks; if `content_truncated` is true in the response, call again with `offset: next_offset` to fetch the next chunk. Output: `{ product, slug, title, headings, content, content_offset, content_length, content_truncated, next_offset, canonical_url, last_updated, source_path }`. `content_length` is the total page size; `content_truncated` + `next_offset` signal whether to paginate.

Parameters3

slug	string	required	Doc slug relative to pages/ (e.g., "rpc-api/daemon-rpc-api", "tutorials/first-app", "dero-pay/quick-start")
product	string	optional	Optional product scope to disambiguate duplicate slugs
offset	integer	optional	Byte offset into the page plaintext. Use 0 (or omit) for the first chunk; pass next_offset from a prior response to continue reading a long page.

Raw schema

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "minLength": 1,
      "description": "Doc slug relative to pages/ (e.g., \"rpc-api/daemon-rpc-api\", \"tutorials/first-app\", \"dero-pay/quick-start\")"
    },
    "product": {
      "description": "Optional product scope to disambiguate duplicate slugs",
      "type": "string",
      "enum": [
        "derod",
        "tela",
        "hologram",
        "deropay"
      ]
    },
    "offset": {
      "description": "Byte offset into the page plaintext. Use 0 (or omit) for the first chunk; pass next_offset from a prior response to continue reading a long page.",
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "slug"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_docs_list

List indexed bundled docs pages across all four products with slugs, titles, and canonical URLs. When to call: when surveying available docs (e.g. "what TELA tutorials exist?"), OR when you need a slug catalog before invoking dero_docs_get_page. PREFER dero_docs_search when you have a specific question. Input Requirements: - `product` is OPTIONAL. Provide to scope to one of `derod | tela | hologram | deropay`. - `limit` is OPTIONAL (default 120, max 500). Output: `{ docs_source, total, products, pages: [{ product, slug, title, canonical_url, last_updated }] }`.

Parameters2

product	string	optional	Optional docs product filter: derod \| tela \| hologram \| deropay
limit	integer	optional	Max pages returned (default 120, max 500)

Raw schema

{
  "type": "object",
  "properties": {
    "product": {
      "description": "Optional docs product filter: derod | tela | hologram | deropay",
      "type": "string",
      "enum": [
        "derod",
        "tela",
        "hologram",
        "deropay"
      ]
    },
    "limit": {
      "description": "Max pages returned (default 120, max 500)",
      "type": "integer",
      "minimum": 1,
      "maximum": 500
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

verify_supply

Composite: recompute DERO total supply offline via CalcSupply (premine + one-time launch credit + Σ CalcBlockReward epochs — DEROFDN community-dev / dero-docs schedule), optionally cross-check against DERO.GetInfo.total_supply. When to call: when the user asks "what is the total supply", "does GetInfo match the schedule", "verify the supply", or wants an independent recompute that does not trust a node. PREFER this over reading GetInfo alone — GetInfo on older builds can undercount after halvings (display quirk, not inflation). PREFER citing the returned related_docs (`integrity/verify-the-supply`). Input Requirements: - `height` is OPTIONAL. Non-negative integer topoheight/height. Default: tip topoheight from DERO.GetInfo. - If the daemon is unreachable you MUST pass `height` — otherwise the tool returns RPC_UNREACHABLE / INVALID_INPUT. Output: `{ height, height_source, calc_supply_atoms, calc_supply_dero, block_reward_atoms, block_reward_dero, getinfo_total_supply, match, formula_note, narrative, related_docs, _diagnostics }`. `match` is true/false when GetInfo.total_supply is present, else null. Scope is schedule CalcSupply only — NOT a UTXO census.

Parameters1

height

integer

optional

Topoheight / height to evaluate. Default: tip topoheight from DERO.GetInfo. Required when the daemon is unreachable.

Raw schema

{
  "type": "object",
  "properties": {
    "height": {
      "description": "Topoheight / height to evaluate. Default: tip topoheight from DERO.GetInfo. Required when the daemon is unreachable.",
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

diagnose_chain_health

Composite: run a four-step chain (DERO.Ping → DERO.GetInfo → DERO.GetHeight → DERO.GetTxPool) and return a single narrative health report with chain metadata, mempool snapshot, machine-readable signals, and curated docs citations. When to call: as the first step in any chain-state investigation when the user asks "is the node healthy", "is it synced", or "what is the current state of the chain". PREFER this over chaining the four primitives yourself — the composite handles partial-failure modes and lag-depth classification consistently, and the response already cites the right docs page. Input Requirements: - `include_tx_pool` is OPTIONAL (default true). Set false to skip the mempool snapshot when you only need chain-tip status. Output: `{ status, narrative, signals[], chain, mempool, related_docs, _diagnostics }`. `status` is one of `healthy | lagging | partial | unreachable`. `chain` is null when DERO.GetInfo was unreachable; `mempool` is null when skipped or the call failed. On total daemon unreachability the tool returns a structured `_meta.error` with code `RPC_UNREACHABLE`.

Parameters1

include_tx_pool

boolean

optional

Include mempool snapshot in narrative and response. Default true.

Raw schema

{
  "type": "object",
  "properties": {
    "include_tx_pool": {
      "description": "Include mempool snapshot in narrative and response. Default true.",
      "type": "boolean"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

explain_smart_contract

Composite: fetch a DERO smart contract (code + variables + balances) and return its function surface, a classification of the contract pattern (tela_index | tela_doc | token | registry | minimal | generic), a plain-language narrative, and curated DVM docs citations re-ordered so the most relevant page is first. TELA contracts (apps/files) are detected first and cite the TELA spec; for a deep TELA parse use tela_inspect. When to call: when the user wants to UNDERSTAND a smart contract — its functions, state shape, or which DVM concept to read about. PREFER this over chaining dero_get_sc with a docs lookup yourself: this composite already parses the DVM-BASIC source for function declarations, sorts stringkeys/uint64keys deterministically, and picks the right docs page from a heuristic so the agent does not have to learn DVM-BASIC syntax to summarize a contract. Input Requirements: - `scid` is REQUIRED. Must be 64 hex chars (the smart contract id). Use `0000…0001` for the on-chain name registry as a known-good example. - `topoheight` is OPTIONAL. Provide to inspect the contract at a specific topo height; omit for latest tip. Output: `{ scid, topoheight, kind, surface: { functions[], stringkeys[], uint64keys[], balances }, narrative, raw_code_length, has_code, related_docs }`. `kind` is one of `tela_index | tela_doc | token | registry | minimal | generic`. `surface.functions` items are `{ name, args, returns }`. `has_code` is false when the SCID is unknown or has no on-chain code; `functions` is then `[]` and the narrative explains the gap. `raw_code_length` is always present so the agent knows when to fall back to `dero_get_sc` for the full source.

Parameters2

scid	string	required	64-char hex Smart Contract ID
topoheight	integer	optional	Optional topo height; omit for latest tip

Raw schema

{
  "type": "object",
  "properties": {
    "scid": {
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$",
      "description": "64-char hex Smart Contract ID"
    },
    "topoheight": {
      "description": "Optional topo height; omit for latest tip",
      "type": "integer",
      "minimum": -9007199254740991,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "scid"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

tela_inspect

Composite: fetch a TELA contract by SCID (DERO.GetSC code + variables) and parse it as either a TELA-INDEX-1 app manifest or a TELA-DOC-1 file contract, auto-detecting which standard it is from the stored keys. TELA is DERO's on-chain web-app platform: an INDEX is the app manifest (like package.json) and DOCs are the individual files (HTML/CSS/JS) stored on chain. When to call: as the FIRST step whenever a user references a TELA SCID, a `.tela` dURL app, or asks "what is this TELA contract/app", "what files does this TELA app have", or "is this a TELA INDEX or DOC". PREFER this over dero_get_sc + manual parsing or explain_smart_contract: explain_smart_contract treats TELA contracts as generic DVM and its surface CAPS stored keys at 50, which silently drops DOCn entries on large manifests — tela_inspect reads the raw stringkeys directly so it enumerates ALL DOC references, and it decodes the TELA header/mods/commit schema the generic tool does not understand. Input Requirements: - `scid` is REQUIRED. Must be 64 hex chars (the TELA contract id). - `topoheight` is OPTIONAL. Provide to inspect at a specific topo height; omit for the latest committed state. Output: a discriminated union on `kind`. `tela_index` → `{ scid, topoheight, kind, index: { name, description, icon, durl, mods[], docs:[{position, key, scid, is_entrypoint, malformed}], doc_count, commit, version_history[], current_commit_hash, owner, updateable:'unknown', updateable_note, parse_notes[] }, narrative, related_docs }`. `tela_doc` → `{ ..., doc: { filename, doc_type, sub_dir, durl, signature, content_embedded, code_size_bytes, immutable }, narrative, related_docs }`. `not_tela` → `{ ..., kind:'not_tela', reason, observed:{ stringkey_sample[], stringkeys_total, has_code, markers[] }, narrative }` — returned (NOT an error) when the SCID is unknown or lacks TELA markers. Updateability cannot be derived from chain state (ringsize is not in GetSC) so it is honestly reported as 'unknown'.

Parameters2

scid	string	required	64-char hex Smart Contract ID of a TELA-INDEX-1 or TELA-DOC-1 contract
topoheight	integer	optional	Optional topo height; omit for the latest committed state

Raw schema

{
  "type": "object",
  "properties": {
    "scid": {
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$",
      "description": "64-char hex Smart Contract ID of a TELA-INDEX-1 or TELA-DOC-1 contract"
    },
    "topoheight": {
      "description": "Optional topo height; omit for the latest committed state",
      "type": "integer",
      "minimum": -9007199254740991,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "scid"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

tela_get_doc_content

Composite: fetch the actual file content stored in a TELA-DOC-1 contract. A DOC's file (HTML/CSS/JS/...) lives inside a DVM-BASIC comment block in the contract code — NOT in a stored variable — so this tool fetches DERO.GetSC, confirms the SCID is a DOC, and extracts the file bytes. Gzip-compressed files (a `.gz` filename, the TELA-CLI default) are transparently base64-decoded + decompressed to plaintext. Large files paginate via offset. When to call: when a user wants to READ or inspect the actual code/markup a TELA app file holds (e.g. "show me the HTML of this TELA DOC", "what does this app's app.js contain"). Get DOC SCIDs from tela_inspect on an INDEX first. PREFER this over dero_get_sc: that returns the raw DVM contract wrapper; this extracts just the embedded file content and reports docType, size, and signature presence. Input Requirements: - `scid` is REQUIRED. Must be 64 hex chars and reference a TELA-DOC-1 contract (an INDEX or non-TELA SCID returns INVALID_INPUT with guidance). - `offset` is OPTIONAL. Byte offset into the extracted content; pass `next_offset` to read the next chunk of a large file. - `topoheight` is OPTIONAL. Omit for the latest committed state. Output: `{ scid, topoheight, filename, doc_type, sub_dir, content_embedded, content, content_offset, content_length, content_truncated, next_offset, compressed, decompressed, stored_filename, signature, signature_note, note, narrative, related_docs }`. `content` is the plaintext file (a 60000-char chunk; paginate via `next_offset`), or null when content is not embedded (DocShard/STATIC/external). `compressed` is true for `.gz` files; `decompressed` is true when this tool gunzipped them (`filename` then strips `.gz`; `stored_filename` keeps the on-chain name). The contract's author signature presence is reported but NOT cryptographically verified.

Parameters3

scid	string	required	64-char hex Smart Contract ID of a TELA-DOC-1 file contract
offset	integer	optional	Byte offset into the extracted file content; use next_offset to paginate large files
topoheight	integer	optional	Optional topo height; omit for latest committed state

Raw schema

{
  "type": "object",
  "properties": {
    "scid": {
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$",
      "description": "64-char hex Smart Contract ID of a TELA-DOC-1 file contract"
    },
    "offset": {
      "description": "Byte offset into the extracted file content; use next_offset to paginate large files",
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    },
    "topoheight": {
      "description": "Optional topo height; omit for latest committed state",
      "type": "integer",
      "minimum": -9007199254740991,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "scid"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_durl_to_scid

Composite: resolve a TELA dURL (e.g. "vault.tela") to its on-chain SCID(s) by discovering TELA apps directly from chain — no external Gnomon indexer required. TELA apps advertise a human-readable dURL; this finds the contract(s) that claim it. When to call: when a user asks "what's the SCID for <something>.tela", "find the TELA app called X", or gives a dURL and wants the contract. IMPORTANT routing: for a registered DERO NAME like "quickbrownfox" (no dot, not a dURL), use dero_name_to_address instead — that is a name to address lookup, not a TELA app. This tool is only for TELA dURLs (they contain a dot / .tela / a dero:// prefix). Input Requirements: - `durl` is REQUIRED. A TELA dURL such as "vault.tela", "feed.tela", or "dero://cipherchess.tela". Case- and prefix-insensitive. Output: `{ query, normalized, found, match_count, scid, primary, collision, other_candidates[], narrative, related_docs }` on a hit; `{ query, normalized, found:false, match_count:0, hint }` on a miss. dURLs are NOT unique — when multiple contracts claim one, the NEWEST is returned as `scid`/`primary` and the rest are disclosed in `other_candidates` with `collision:true`. The first call triggers a ~10s one-time discovery scan of the newest chain contracts (cached afterward). Feed the returned scid to tela_inspect to view the app.

Parameters1

durl

string

required

A TELA dURL to resolve, e.g. "vault.tela" or "dero://feed.tela". NOT a registered DERO name (use dero_name_to_address for names like "quickbrownfox").

Raw schema

{
  "type": "object",
  "properties": {
    "durl": {
      "type": "string",
      "minLength": 1,
      "description": "A TELA dURL to resolve, e.g. \"vault.tela\" or \"dero://feed.tela\". NOT a registered DERO name (use dero_name_to_address for names like \"quickbrownfox\")."
    }
  },
  "required": [
    "durl"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_tela_list_apps

Composite: list/browse the TELA apps discovered on-chain (each with its dURL, name, SCID, and doc count) — answers "what TELA apps exist?" without any external indexer. Powered by an in-process scan of the newest chain contracts. When to call: when a user wants to explore or search the TELA ecosystem ("what TELA apps are there", "show me TELA games", "is there a TELA app about X"), or to find a SCID when they do not know the exact dURL. For an exact dURL use dero_durl_to_scid; to inspect a specific SCID use tela_inspect. Input Requirements: - `query` is OPTIONAL. Case-insensitive filter matched against dURL and name (e.g. "chess", "vault"). - `limit` is OPTIONAL (default 50, max 200). Output: `{ query, total_matched, returned, truncated, apps:[{ scid, durl, name, install_height, doc_count }], index_meta, narrative, related_docs }`. The first call triggers a ~10s one-time discovery scan (cached afterward). `index_meta` discloses how much of the chain was scanned so the answer's coverage is transparent.

Parameters2

query	string	optional	Optional case-insensitive filter matched against dURL and name (e.g. "chess", "vault").
limit	integer	optional	Max apps to return (default 50, max 200).

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "description": "Optional case-insensitive filter matched against dURL and name (e.g. \"chess\", \"vault\").",
      "type": "string"
    },
    "limit": {
      "description": "Max apps to return (default 50, max 200).",
      "type": "integer",
      "minimum": 1,
      "maximum": 200
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

recommend_docs_path

Composite: take a natural-language intent, fan out parallel scoped searches across the bundled docs for all four DERO products (derod, tela, hologram, deropay), boost any product_hint matches by 1.5×, and return a ranked recommendation list with per-result rationale plus ready-to-cite related_docs. When to call: at the START of any "where do I read about X?" or "which docs cover Y?" investigation, BEFORE calling dero_docs_search directly. PREFER this over guessing the right product: this composite already runs all four products in parallel, dedupes overlap, surfaces the top heading per result as rationale, and gives you the top-2 citations pre-built. Pass product_hint when the user has already said e.g. "TELA" or "DeroPay" so that product's matches float to the top. Input Requirements: - `intent` is REQUIRED. Free-text description of what the user is trying to do (min 8 chars). Drop verbs and use product nouns like "deploy a TELA app" or "verify a DeroPay webhook signature" for best results. - `product_hint` is OPTIONAL. One of `derod | tela | hologram | deropay`. Multiplies hint-product scores by 1.5×. - `limit_per_product` is OPTIONAL (default 2, max 5). Cap per-product hits before merging. Output: `{ intent, product_hint, limit_per_product, recommended: [{ product, slug, title, canonical_url, score, boosted_score, rationale }], by_product: { derod | tela | hologram | deropay: { count, top_slug, top_score } }, related_docs: DeroCitation[] }`. `related_docs` is the top-2 picks pre-built as citations the agent can drop straight into a response. On zero matches across every product the composite returns a structured `_meta.error` with code `NO_DOCS_MATCH` and a hint to rephrase or drop the product_hint.

Parameters3

intent	string	required	Natural-language description of what the user wants to do (e.g. "deploy a TELA app", "trace a transaction by hash", "verify a webhook signature").
product_hint	string	optional	Optional bias toward one product (derod \| tela \| hologram \| deropay) when known.
limit_per_product	integer	optional	Cap per-product search results before merging. Default 2.

Raw schema

{
  "type": "object",
  "properties": {
    "intent": {
      "type": "string",
      "minLength": 8,
      "description": "Natural-language description of what the user wants to do (e.g. \"deploy a TELA app\", \"trace a transaction by hash\", \"verify a webhook signature\")."
    },
    "product_hint": {
      "description": "Optional bias toward one product (derod | tela | hologram | deropay) when known.",
      "type": "string",
      "enum": [
        "derod",
        "tela",
        "hologram",
        "deropay"
      ]
    },
    "limit_per_product": {
      "description": "Cap per-product search results before merging. Default 2.",
      "type": "integer",
      "minimum": 1,
      "maximum": 5
    }
  },
  "required": [
    "intent"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

estimate_deploy_cost

Composite: send a DVM-BASIC contract source to the daemon's gas estimator, then return the raw estimate alongside a plain-text breakdown (what each gas number means), the parsed contract surface, and curated DVM deploy docs as citations. When to call: BEFORE asking a wallet to broadcast a deploy transaction, OR when explaining the cost of a contract to a user. PREFER this over chaining dero_get_gas_estimate yourself: this composite already explains gascompute vs gasstorage in plain language, parses the SC source to show what functions the user is about to deploy (reusing extractScSurface from explain_smart_contract), and protects against fabricating a breakdown when the daemon reports 0/0 with a non-OK status. Input Requirements: - `sc` is REQUIRED. The full DVM-BASIC contract source — must contain at least one `Function ... End Function` block. A function body alone will fail with INVALID_INPUT. - `signer` is OPTIONAL. A dero1.../deto1... address that will sign the eventual deploy tx. The daemon uses it for fee context; omitting it still returns a meaningful estimate. - `include_breakdown` is OPTIONAL (default true). Set false when you only need the raw numbers (e.g. piping into a fee table). Output: `{ estimate: { gascompute, gasstorage, status }, breakdown: { compute_note, storage_note, total_units } | null, signer_used, include_breakdown, sc_surface: { functions, stringkeys, uint64keys, raw_code_length, function_count }, related_docs }`. `breakdown` is null when `include_breakdown=false` OR when the daemon returned 0/0 with a non-OK status (never fabricated). On DVM compile failure the composite returns a structured `_meta.error` with code `INVALID_INPUT` and the daemon's exact compile message in `_meta.error.raw`.

Parameters3

sc	string	required	DVM-BASIC contract source to deploy. MUST be the full contract (Function ... End Function blocks), not a function body alone.
signer	string	optional	Optional dero1.../deto1... signer for the eventual deploy tx.
include_breakdown	boolean	optional	Default true. Set false to return raw estimate numbers only.

Raw schema

{
  "type": "object",
  "properties": {
    "sc": {
      "type": "string",
      "minLength": 1,
      "description": "DVM-BASIC contract source to deploy. MUST be the full contract (Function ... End Function blocks), not a function body alone."
    },
    "signer": {
      "description": "Optional dero1.../deto1... signer for the eventual deploy tx.",
      "type": "string",
      "pattern": "^(dero1|deto1)[0-9a-z]+$"
    },
    "include_breakdown": {
      "description": "Default true. Set false to return raw estimate numbers only.",
      "type": "boolean"
    }
  },
  "required": [
    "sc"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

trace_transaction_with_context

Composite: look up a DERO transaction by hash, classify its confirmation status (confirmed | mempool | unknown) and kind (sc_install | transfer_or_invocation | coinbase | unknown), extract the SC surface inline when the tx is a contract install, and stitch the right DERO tx + DVM docs pages as citations. When to call: as the FIRST step when investigating any tx by hash — the user asks "what is this tx", "is this confirmed", "what contract did this deploy", or "what does this tx do". PREFER this over chaining dero_get_transaction with dero_get_sc yourself: for SC INSTALL txs the composite already extracts the deployed function surface inline (no second RPC needed because the source is embedded in the tx record), classifies the kind so the agent does not have to inspect the raw shape, and protects against the "empty record" failure mode by surfacing structured TX_NOT_FOUND when the daemon does not know the hash. Input Requirements: - `tx_hash` is REQUIRED. Must be 64 hex chars. - `decode` is OPTIONAL (default true). Pass false to ask the daemon to skip the JSON-decoded view (raw hex still comes back; the field hint that the binary is available). - `include_sc_context` is OPTIONAL (default true). Set false to skip the inline extractScSurface call for SC install txs (useful when you only need confirmation / ring info). Output: `{ tx_hash, confirmation: { status, block_height, valid_block, invalid_blocks, in_pool }, kind, ring: { groups, first_group_size }, reward, signer_visible, native_balance, sc_install: { scid, surface, raw_code_length, has_code } | null, raw_tx_hex_length, narrative, related_docs, _diagnostics }`. `sc_install` is non-null ONLY when the tx is a contract install AND the surface extractor produced something (tx_hash IS the resulting SCID in that case). SC invocation arg decoding is NOT performed — that requires walking the binary tx blob with the DERO tx codec, which is not bundled in this MCP. The composite surfaces `raw_tx_hex_length` so the agent knows the binary is available via dero_get_transaction. On unknown hash the daemon returns an empty record and the composite returns a structured `_meta.error` with code `TX_NOT_FOUND`.

Parameters3

tx_hash	string	required	64-char hex transaction hash
decode	boolean	optional	Pass decode_as_json=1 to the daemon. Default true. Decoded JSON view is informational; the raw hex always comes back.
include_sc_context	boolean	optional	When true (default), runs the SC-install surface extraction inline when the tx contains contract code. SC invocation arg decoding is NOT performed in either mode; see module docs.

Raw schema

{
  "type": "object",
  "properties": {
    "tx_hash": {
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$",
      "description": "64-char hex transaction hash"
    },
    "decode": {
      "description": "Pass decode_as_json=1 to the daemon. Default true. Decoded JSON view is informational; the raw hex always comes back.",
      "type": "boolean"
    },
    "include_sc_context": {
      "description": "When true (default), runs the SC-install surface extraction inline when the tx contains contract code. SC invocation arg decoding is NOT performed in either mode; see module docs.",
      "type": "boolean"
    }
  },
  "required": [
    "tx_hash"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

audit_chain_artifact_claim

Composite: audit a chain artifact (block topoheight, block hash, TX hash, and/or proof string) end-to-end. Returns a verdict (`cited_in_false_claim` | `clean`), the actual on-chain facts (block reward, TX acceptance status), an optional proof-string decode, a relayable narrative, and curated rebuttal docs citations. When to call: when the user asks "what's going on with DERO block X?" / "is this transaction the inflation-claim TX?" / "does this proof string come from a known false claim?" PREFER this over chaining `dero_get_block_header_by_topo_height` + `dero_get_transaction` + `dero_decode_proof_string` yourself: the composite already runs them in parallel, joins them against the flagged false-claim registry, and emits a single `verdict` field plus a narrative so the agent does not need to compose the rebuttal arc from scratch each time. Input Requirements (CRITICAL): - At least ONE of `topoheight`, `block_hash`, `tx_hash`, or `proof_string` MUST be provided. The composite throws `INVALID_INPUT` otherwise. - `topoheight` is OPTIONAL. Non-negative integer. - `block_hash` is OPTIONAL. 64 hex characters. - `tx_hash` is OPTIONAL. 64 hex characters. - `proof_string` is OPTIONAL. Full `deroproof…` / DERO bech32 string with HRP. - `include_forge_demo` is OPTIONAL (default false). When true AND `tx_hash` is provided, also forges a fresh demo proof for the same TX (via `dero_forge_demo_proof`) and embeds it under `forge_demo`. The demo amount auto-selects: a flagged artifact's pinned amount (e.g. -2.2M for the 2022 claim) > the cited `proof_string` V > -1 DERO. PREFER setting this true when the agent is fielding a "Verified ✓ means the chain minted coins, right?" question — the embedded forge IS the refutation. Output: `{ verdict, inputs, matched_artifacts[], context_note, chain_facts, proof_decode, forge_demo, narrative, related_docs, _diagnostics }`. `verdict` is `cited_in_false_claim` when any input matches the flagged-artifact registry, else `clean`. `chain_facts` is null when no chain-querying input was provided or all daemon calls failed; `proof_decode` is null when no `proof_string` was provided. `forge_demo` is null unless `include_forge_demo: true` was passed; on success it carries `{ skipped: false, forged_proof_string, target_amount, ring_slot, ring_size, ring_receiver_address, math, self_check, explorer_display_amount, demo_amount_source }` (the slim form — full citations stay at the top level). PREFER citing the returned `related_docs` verbatim in the agent response — they are the canonical rebuttal pages and have been validated against the bundled docs index by CI. Quote the `context_note` when verdict is `cited_in_false_claim` so the user understands why the artifact matters.

Parameters5

topoheight	integer	optional	Topological height of a block to audit.
block_hash	string	optional	64-char hex block hash to audit.
tx_hash	string	optional	64-char hex transaction hash to audit.
proof_string	string	optional	Optional `deroproof…` / DERO bech32 string to also decode and check.
include_forge_demo	boolean	optional	When true AND tx_hash is provided, also forge a fresh demo proof for the same TX (via dero_forge_demo_proof) and embed it under `forge_demo`. Closes the rebuttal loop in one tool call. Default false.

Raw schema

{
  "type": "object",
  "properties": {
    "topoheight": {
      "description": "Topological height of a block to audit.",
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    },
    "block_hash": {
      "description": "64-char hex block hash to audit.",
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$"
    },
    "tx_hash": {
      "description": "64-char hex transaction hash to audit.",
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$"
    },
    "proof_string": {
      "description": "Optional `deroproof…` / DERO bech32 string to also decode and check.",
      "type": "string",
      "minLength": 8
    },
    "include_forge_demo": {
      "description": "When true AND tx_hash is provided, also forge a fresh demo proof for the same TX (via dero_forge_demo_proof) and embed it under `forge_demo`. Closes the rebuttal loop in one tool call. Default false.",
      "type": "boolean"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

dero_forge_demo_proof

Composite: build a fresh `deroproof…` display object for ANY chosen transaction, ring slot, and amount — including negative amounts that uint64-wrap into the trillions. The forged string is constructed locally from public chain data (no wallet, no keys, no broadcast). On an unpatched explorer it shows **Verified ✓** for the chosen amount; on the chain, nothing has changed. When to call: when a user pastes a `deroproof…` string and asks "does Verified ✓ mean the chain minted these coins?" Forge an equivalent string for the same TX with a different amount and show the result side-by-side — that is the most direct refutation. Also useful for reproducing the `docs/integrity/inflation-claim` Part 3 demonstration on arbitrary inputs. Math: `blinder = C[ring_slot] − amount × G`, then `bech32("deroproof", version || blinder || CBOR({HH: zeros, VU: uint64}))`. The tool runs the same equation `proof.Prove()` checks at `proof/proof.go:88-95` and self-verifies before returning a string. If the self-check fails, the tool throws rather than emit a string that would not verify. Input Requirements (CRITICAL): - Exactly ONE of `tx_hash` or `tx_hex` MUST be provided. `tx_hash` triggers a daemon fetch (and surfaces the receiver address); `tx_hex` skips the daemon and uses the raw bytes the caller already has. - `ring_slot` is OPTIONAL (default 0). Must be in [0, ring_size). - `amount_dero` is OPTIONAL (default "-1"). Signed decimal with up to 5 fractional digits, e.g. `"-1"`, `"1000000"`, `"-2200000.00181"`. Negative values produce uint64 wraparounds that unpatched explorers render as positive trillions. Output: `{ forged_proof_string, target_amount: { dero, atoms_signed, atoms_uint64 }, ring_slot, ring_size, ring_receiver_address, math: { C_slot_hex, amount_x_G_hex, blinder_hex }, self_check: { verified, method }, explorer_display_amount, context_note, related_docs, _diagnostics }`. `ring_receiver_address` is null when `tx_hex` was passed (the hex carries publickey pointers, not addresses). READ-ONLY: this tool never broadcasts, never touches a wallet, never mutates chain state. It computes a string from public inputs and returns it. Annotation `readOnlyHint: true` is preserved. PREFER citing the returned `related_docs` (the integrity rebuttal pages) in any agent response — readers should understand the forged string is a display-layer object, not a consensus event.

Parameters4

tx_hash	string	optional	TX hash to forge against. Daemon fetches the TX hex + ring members. Mutually exclusive with tx_hex.
tx_hex	string	optional	Raw TX bytes as hex (skip the daemon round-trip). Mutually exclusive with tx_hash. When provided, ring_receiver_address is omitted from the response (the hex carries publickey pointers, not full addresses).
ring_slot	integer	optional	Which ring slot 0..ring_size-1 the forged proof should resolve to. Defaults to 0.
amount_dero	string	optional	Target display amount in signed DERO (5 fractional digits = atomic precision). Negative values demonstrate the uint64 wraparound. Default "-1".

Raw schema

{
  "type": "object",
  "properties": {
    "tx_hash": {
      "description": "TX hash to forge against. Daemon fetches the TX hex + ring members. Mutually exclusive with tx_hex.",
      "type": "string",
      "pattern": "^[0-9a-fA-F]{64}$"
    },
    "tx_hex": {
      "description": "Raw TX bytes as hex (skip the daemon round-trip). Mutually exclusive with tx_hash. When provided, ring_receiver_address is omitted from the response (the hex carries publickey pointers, not full addresses).",
      "type": "string",
      "minLength": 2,
      "maxLength": 100000
    },
    "ring_slot": {
      "default": 0,
      "description": "Which ring slot 0..ring_size-1 the forged proof should resolve to. Defaults to 0.",
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    },
    "amount_dero": {
      "default": "-1",
      "description": "Target display amount in signed DERO (5 fractional digits = atomic precision). Negative values demonstrate the uint64 wraparound. Default \"-1\".",
      "type": "string",
      "pattern": "^-?\\d+(\\.\\d{1,5})?$"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

README.md16 KBView on GitHub

DERO MCP server

A read-only Model Context Protocol server for the DERO privacy blockchain — a private-by-default Layer 1 with encrypted balances, private smart contracts (DVM-BASIC), and no public transaction graph. 21 daemon primitives + 12 composite tools (including TELA on-chain app inspection and dURL→SCID discovery), with a bundled documentation index spanning derod, tela, hologram, and deropay.

Registry listing: io.github.DHEBP/dero-mcp-server · Version: 0.6.0 · Transports: stdio (default, npm package) · streamable-http (--http, for self-hosting)

What is an MCP server

An MCP server (Model Context Protocol) is a small program that gives your AI assistant — Claude Desktop, Cursor, OpenCode, ChatGPT with Custom Connectors — the ability to call specific tools on your behalf. Instead of the AI talking about DERO from memory, it can actually look things up: fetch a block, read a contract, search the docs, trace a transaction, estimate a deploy.

You install it once and point your AI host at it. From then on, every DERO question you ask in chat hits live chain data and the bundled docs corpus — not the AI's training cutoff.

What is DERO

If you're new to DERO: it's a privacy-first L1 blockchain — often described as a private alternative to Ethereum for builders who want smart contracts without a transparent ledger, or as a Monero alternative for users who want account-based privacy with native programmability instead of UTXO-only payments. Homomorphically encrypted balances. Ring signatures hide senders. Zero-knowledge range proofs (Bulletproofs) hide amounts. There is no public transaction graph. The current mainnet is DERO Stargate.

Full docs: derod.org

About this server

Model Context Protocol (MCP) server that exposes read-only and analysis calls against a DERO Stargate daemon JSON-RPC endpoint. Ships as a stdio process for local MCP hosts (Claude Desktop, Cursor, OpenCode) or in streamable-HTTP mode behind a domain (e.g. mcp.derod.org) for ChatGPT Custom Connectors, Cursor hosted mode, and any agent that needs a remote URL. See deploy/ for a reference self-hosted deployment.

Quick start

Get a working DERO MCP connection in under 5 minutes.

What you need

Node.js 20+ (install) — verify with node --version.
An MCP host — Claude Desktop, Cursor, OpenCode, or ChatGPT with Custom Connectors. This walkthrough uses Claude Desktop; the JSON config below works identically in Cursor and OpenCode.
Optional: a local DERO daemon. If one is running on 127.0.0.1:10102, the server detects and uses it automatically; otherwise it falls back to a public RPC, so it works with zero setup. Run your own for production — how to.

1. Open your MCP host's config

Host	Where
Claude Desktop (macOS)	`~/Library/Application Support/Claude/claude_desktop_config.json`
Claude Desktop (Windows)	`%APPDATA%\Claude\claude_desktop_config.json`
Cursor	Settings → MCP → Add Server
OpenCode	Settings → MCP → Add Server
Codex CLI / IDE	`codex mcp add` or `~/.codex/config.toml`

Create the file if it doesn't exist.

2. Add the DERO MCP server

json

{
  "mcpServers": {
    "dero-daemon": {
      "command": "npx",
      "args": ["-y", "dero-mcp-server"]
    }
  }
}

This uses npx to fetch and run the latest published version — no manual install or build required.

The server auto-detects a local node at 127.0.0.1:10102. To pin a specific daemon (custom port or a remote URL), add an env block:

json

"env": { "DERO_DAEMON_URL": "http://127.0.0.1:10102" }

3. Restart your MCP host

Fully quit and reopen — not just refresh. MCP servers load at startup.

4. Verify it works

In a new chat:

"What's the current DERO chain height?"

A number back means you're connected. If you see an error, confirm the config file path is correct and your host was fully restarted (not just refreshed).

Once it's working, jump to Try a prompt for a full tour.

What you can do with it

Once installed, your MCP host can do all of these on your behalf — in natural language, no JSON-RPC needed:

Inspect the chain — blocks, transactions, mempool, encrypted balances, registered names
Analyze smart contracts — read code and state, classify the pattern, estimate deploy gas, pull relevant DVM-BASIC docs in one call
Trace transactions — look up any hash, confirm inclusion, classify the kind (transfer / SC install / SC call)
Explore the on-chain web (TELA) — discover apps by name (vault.tela → SCID), browse what's deployed, inspect an app's manifest and files, and read the actual on-chain HTML/JS/CSS — no separate indexer to run
Search the docs — across all four DERO sites (derod, tela, hologram, deropay)
Run composite analyses — chain health, claim audits, docs path recommendations, deploy pre-flights — each returns curated DERO docs citations alongside the data

Try a prompt

After installing and restarting your MCP host, paste any of these. Start simple and work up.

Basic

Single-tool questions that verify the install and exercise live queries.

"What's the current DERO chain height?"

"Resolve the DERO name 'engram' to an address."

"Find the documentation page on Bulletproofs."

"What does the smart contract at SCID 0000…0001 do?"

Intermediate

Composite tools that fan out into multiple primitives and return a synthesized answer with citations.

"Explain the smart contract at SCID 0000000000000000000000000000000000000000000000000000000000000001 — what it does, its functions, and which DVM-BASIC docs are relevant."

"Trace transaction with full context — confirmation, classification, and what it touched."

"What's the right reading path for someone new to DERO smart contracts who wants to deploy a DVM-BASIC contract?"

"Estimate the gas cost to deploy this DVM source: "

TELA — the decentralized web on DERO

TELA apps are full web apps (HTML/CSS/JS) deployed entirely on-chain. The server discovers and reads them with no external indexer — the first discovery query runs a one-time ~15s scan, then it's instant.

"What's the SCID for vault.tela?"

"What TELA apps exist on DERO? Show me a few."

"Inspect the TELA app at SCID — what is it, who made it, and what files does it have?"

"Show me the actual HTML of that app's index.html."

For multi-step agent recipes, per-tool guidance, error contract, and the composite-first rule, see SKILL.md.

Not included (by design): wallet RPC (transfer, scinvoke), DERO.SendRawTransaction, DERO.SubmitBlock. Those can move funds or consensus data; add them only with explicit user consent and a locked-down setup.

Requirements

Node.js 20+
A reachable DERO daemon with RPC enabled (local node or your own remote URL).

Install & build

bash

cd dero-mcp-server
npm install
npm run build

Run (auto-detects a local node at 127.0.0.1:10102, else public fallback, when DERO_DAEMON_URL is unset):

bash

node dist/index.js

Or set an explicit URL (e.g. your local daemon):

bash

DERO_DAEMON_URL=http://127.0.0.1:10102 node dist/index.js

Daemon resolution is local-first: with DERO_DAEMON_URL unset, the server uses a local node at 127.0.0.1:10102 if it answers, else the baked-in third-party public RPC (82.65.143.182:10102). Prefer your own node for privacy.

Strip a trailing /json_rpc if you paste a full JSON-RPC URL — this server appends /json_rpc.

HTTP mode (self-hosted)

For clients that can't launch a local subprocess — ChatGPT Custom Connectors, Cursor hosted mode, n8n / Zapier integrations — run the server in streamable-HTTP mode and put it behind your own domain:

bash

DERO_MCP_AUTH_TOKEN=$(openssl rand -base64 48) \
  dero-mcp-server --http
# [dero-mcp-server] HTTP listening on 127.0.0.1:8787 (POST /mcp · GET /health)

Both stdio and HTTP serve MCP 2026-07-28 and retain compatibility with 2025-era clients. HTTP exchanges are stateless and do not issue Mcp-Session-Id; 2026 clients negotiate through server/discover.

Variable	Default	Description
`DERO_MCP_HTTP`	unset	Set to `1` (or pass `--http`) to start in HTTP mode.
`DERO_MCP_HTTP_PORT`	`8787`	Listen port.
`DERO_MCP_HTTP_HOST`	`127.0.0.1`	Listen address. Use `0.0.0.0` to bind publicly (do not without auth + TLS upstream).
`DERO_MCP_AUTH_TOKEN`	unset	If set, every `/mcp` request must carry `Authorization: Bearer <token>`. Constant-time compared.

For a turnkey deploy with Caddy + auto-TLS + Docker Compose, see deploy/README.md. It's a self-hosting reference for mcp.derod.org-style instances — anyone can fork and run their own. The public default daemon behind a hosted instance may use an older GetInfo schedule formula than CalcSupply; verify_supply still treats the offline schedule number as authoritative (see Verify the Supply).

The stdio transport (below) and the HTTP transport share the same underlying server factory, so the tool surface, response shapes, and error codes are identical across both.

Claude Desktop (same pattern for OpenCode and Cursor)

Add to claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):

json

{
  "mcpServers": {
    "dero-daemon": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/dero-mcp-server/dist/index.js"]
    }
  }
}

Optional: add "env": { "DERO_DAEMON_URL": "http://127.0.0.1:10102" } to pin a specific daemon. Not needed if your local node uses the default port — the server auto-detects it.

Restart Claude Desktop (or your OpenCode/Cursor host).

Cursor (or OpenCode)

In Cursor Settings → MCP (or OpenCode MCP settings), add a server that runs the same command / args / env as above.

OpenCode

In OpenCode MCP settings, add a server with the same command / args / env as above.

Codex

Codex supports DERO MCP as either a local stdio server or a streamable-HTTP server. The stdio setup is simplest for local development because Codex launches the server process for each session.

Add the published npm package with:

bash

codex mcp add dero-daemon --env DERO_DAEMON_URL=http://127.0.0.1:10102 -- npx -y dero-mcp-server

Replace http://127.0.0.1:10102 with your daemon base URL when using a custom host or port. Do not include /json_rpc; this server appends it.

Equivalent ~/.codex/config.toml:

toml

[mcp_servers.dero-daemon]
command = "npx"
args = ["-y", "dero-mcp-server"]

[mcp_servers.dero-daemon.env]
DERO_DAEMON_URL = "http://127.0.0.1:10102"

A copyable example lives at .codex/config.example.toml. Rename or copy it to .codex/config.toml only when you want a project-scoped Codex config; Codex loads project config only for trusted projects.

For an already-running streamable-HTTP deployment, add the URL instead:

bash

codex mcp add dero-daemon --url http://127.0.0.1:8787/mcp

If the HTTP server requires a bearer token, store the token in an environment variable and add --bearer-token-env-var DERO_MCP_AUTH_TOKEN.

Restart Codex or start a new session, then run /mcp to confirm dero-daemon is enabled. A simple verification prompt is:

"What's the current DERO chain height?"

Environment

Variable	Default	Description
`DERO_DAEMON_URL`	(local-first auto-detect)	Daemon base URL (no `/json_rpc` required). Unset → local node at `127.0.0.1:10102` if reachable, else public fallback (`82.65.143.182:10102`). Set to pin a specific endpoint.
`DERO_DOCS_ROOT`	bundled index	Optional dev override: path to a local `dero-docs` clone to index live MDX instead of the shipped bundle.

Maintainer: bundled docs

Docs tools read from data/docs-index.json, committed in this repo and shipped with the npm package. Rebuild the index when dero-docs changes:

bash

npm run release:docs-check
git add data/docs-index.json && git commit -m "Refresh bundled docs index."

Or run Refresh docs bundle under Actions to open a PR. Pushes to dero-docs main can trigger that workflow via repository_dispatch when MCP_DOCS_SYNC_TOKEN is configured on the docs repo.

After merging a bundle update: bump the patch version in package.json and server.json, then npm publish --otp=... and mcp-publisher publish.

Testing

bash

# Check daemon connectivity
npm run doctor

# MCP surface contract checks (tools/resources/prompts + error probe)
npm run smoke:mcp

# Docs retrieval checks (bundled index — no clone required)
npm run smoke:docs

# Run flow tests (10 RPC checks)
npm run test:flows

# Typecheck
npm run typecheck

Flow tests run against the default public RPC. Set DERO_DAEMON_URL to test against your own daemon.

CI runs on every push and PR — see .github/workflows/ci.yml.

Official MCP Registry

Publish flow (maintainers):

bash

mcp-publisher validate
mcp-publisher login github
mcp-publisher publish

Verify listing:

bash

curl "https://registry.modelcontextprotocol.io/v0.1/servers?search=io.github.DHEBP/dero-mcp-server"

MCP Surface

Tools (33): 21 daemon read/analysis primitives + 12 composites, including verify_supply (offline CalcSupply), TELA app inspection (tela_inspect, tela_get_doc_content), TELA discovery (dero_durl_to_scid, dero_tela_list_apps), and docs retrieval (dero_docs_search, dero_docs_get_page, dero_docs_list)
Resources (4): dero://mcp/server-info, dero://mcp/safety-boundary, dero://mcp/example-flows, dero://mcp/composites
Prompts (5): network_health_check, inspect_smart_contract, trace_transaction, find_dero_docs_for_intent, estimate_deploy_for_contract

Error Contract

When a tool call fails, the server returns a structured error payload in tool content:

json

{
  "ok": false,
  "tool": "dero_get_sc",
  "_meta": {
    "error": {
      "code": "RPC_UNREACHABLE",
      "hint": "Confirm daemon is running and reachable, then rerun `npm run doctor`.",
      "retryable": true,
      "raw": "fetch failed"
    }
  }
}

Common code values:

INVALID_INPUT
RPC_INVALID_PARAMS
RPC_METHOD_NOT_FOUND
RPC_HTTP_ERROR
RPC_UNREACHABLE
RPC_INVALID_RESPONSE
TOOL_EXECUTION_ERROR

Roadmap

Optional wallet-RPC tools behind DERO_ENABLE_WALLET_RPC=1 + separate URL.
Stricter typing / OpenAPI-derived tool schemas.
TELA-aware contract tooling (INDEX/DOC inspection, on-chain app discovery).

License

MIT

Install

Tools (33)

dero_daemon_pingdero_daemon_echodero_get_infodero_get_heightdero_get_block_countdero_get_last_block_headerdero_get_blockdero_get_block_header_by_topo_height

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "dero-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "dero-mcp-server@0.6.0"
      ]
    }
  }
}

io.github.DHEBP/dero-mcp-server: Model Context Protocol Server

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

Topics

dero_daemon_ping

dero_daemon_echo

dero_get_info

dero_get_height

dero_get_block_count

dero_get_last_block_header

dero_get_block

dero_get_block_header_by_topo_height

dero_get_block_header_by_hash

dero_get_tx_pool

dero_get_random_address

dero_get_transaction

dero_get_encrypted_balance

dero_get_sc

dero_get_gas_estimate

dero_name_to_address

dero_get_block_template

dero_decode_proof_string

dero_docs_search

dero_docs_get_page

dero_docs_list

verify_supply

diagnose_chain_health

explain_smart_contract

tela_inspect

tela_get_doc_content

dero_durl_to_scid

dero_tela_list_apps

recommend_docs_path

estimate_deploy_cost

trace_transaction_with_context

audit_chain_artifact_claim

dero_forge_demo_proof

DERO MCP server

What is an MCP server

What is DERO

About this server

Quick start

What you need

1. Open your MCP host's config

2. Add the DERO MCP server

3. Restart your MCP host

4. Verify it works

What you can do with it

Try a prompt

Basic

Intermediate

TELA — the decentralized web on DERO

See also

Requirements

Install & build

HTTP mode (self-hosted)

Claude Desktop (same pattern for OpenCode and Cursor)

Cursor (or OpenCode)

OpenCode

Codex

Environment

Maintainer: bundled docs

Testing

Official MCP Registry

MCP Surface

Error Contract

Roadmap

License

Install

Related servers