dero-mcp-server 0.1.0 → 0.1.1

package/.github/workflows/ci.yml

@@ -0,0 +1,62 @@
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18, 20, 22]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: MCP smoke probes
+        run: npm run smoke:mcp
+        env:
+          DERO_DAEMON_URL: ${{ secrets.DERO_DAEMON_URL || '' }}
+
+      - name: Run flow tests
+        run: npm run test:flows
+        env:
+          # Uses default public RPC (82.65.143.182:10102)
+          # Override with repository secret if you have a dedicated test daemon
+          DERO_DAEMON_URL: ${{ secrets.DERO_DAEMON_URL || '' }}
+
+  typecheck:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Typecheck
+        run: npx tsc --noEmit

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DHEBP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,12 +1,17 @@
 # DERO MCP server
 
+[![CI](https://github.com/DHEBP/dero-mcp-server/actions/workflows/ci.yml/badge.svg)](https://github.com/DHEBP/dero-mcp-server/actions/workflows/ci.yml)
+[![dero-mcp-server MCP server](https://glama.ai/mcp/servers/DHEBP/dero-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/DHEBP/dero-mcp-server)
+
 [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server that exposes **read-only and analysis** calls against a DERO Stargate **daemon** JSON-RPC endpoint. Use it from **Claude Desktop**, **Cursor**, or any MCP client that launches a local process over stdio.
 
 ## What it does
 
 - Connects to `{DERO_DAEMON_URL}/json_rpc` (default `http://82.65.143.182:10102`).
 - Registers one MCP tool per common daemon method (`DERO.GetInfo`, `DERO.GetHeight`, `DERO.GetSC`, etc.).
+- Exposes MCP resources and prompts for consistent investigation workflows.
 - Returns JSON results as MCP text content.
+- Returns structured tool errors with `_meta.error` (`code`, `hint`, `retryable`) to help agents self-correct.
 
 **Not included (by design in v0.1):** 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.
 
@@ -68,6 +73,61 @@ In **Cursor Settings → MCP**, add a server that runs the same `command` / `arg
 |----------|---------|-------------|
 | `DERO_DAEMON_URL` | `http://82.65.143.182:10102` | Daemon **base** URL (no `/json_rpc` required). Set to `http://127.0.0.1:10102` for a local daemon. |
 
+## Testing
+
+```bash
+# Check daemon connectivity
+npm run doctor
+
+# MCP surface contract checks (tools/resources/prompts + error probe)
+npm run smoke:mcp
+
+# 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`.
+
+## MCP Surface
+
+- **Tools (17):** daemon read and analysis methods (`dero_get_info`, `dero_get_sc`, `dero_get_transaction`, etc.)
+- **Resources (3):** `dero://mcp/server-info`, `dero://mcp/safety-boundary`, `dero://mcp/example-flows`
+- **Prompts (3):** `network_health_check`, `inspect_smart_contract`, `trace_transaction`
+
+## 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.

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAqBnE,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAuSpE"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAqKnE,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAsdpE"}

package/dist/server.js

@@ -6,6 +6,42 @@ const scRpcArgSchema = z.object({
     datatype: z.enum(['S', 'U', 'H']),
     value: z.union([z.string(), z.number()]),
 });
+const hex64Schema = z
+    .string()
+    .regex(/^[0-9a-fA-F]{64}$/, 'Expected 64-character hex string');
+const deroAddressSchema = z
+    .string()
+    .regex(/^(dero1|deto1)[0-9a-z]+$/i, 'Expected DERO address starting with dero1 or deto1');
+const NAME_REGISTRY_SCID = '0000000000000000000000000000000000000000000000000000000000000001';
+const DERO_TOOL_NAMES = [
+    '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',
+];
+const DERO_RESOURCE_URIS = [
+    'dero://mcp/server-info',
+    'dero://mcp/safety-boundary',
+    'dero://mcp/example-flows',
+];
+const DERO_PROMPT_NAMES = [
+    'network_health_check',
+    'inspect_smart_contract',
+    'trace_transaction',
+];
 function toolText(data) {
     return {
         content: [
@@ -16,6 +52,87 @@ function toolText(data) {
         ],
     };
 }
+function classifyToolError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes('Provide either hash or height')) {
+        return {
+            code: 'INVALID_INPUT',
+            hint: 'Pass exactly one of "hash" or "height".',
+            retryable: false,
+        };
+    }
+    if (message.includes('RPC error -32601')) {
+        return {
+            code: 'RPC_METHOD_NOT_FOUND',
+            hint: 'Your daemon may be outdated or not a Stargate endpoint. Verify DERO_DAEMON_URL.',
+            retryable: false,
+        };
+    }
+    if (message.includes('RPC error -32602')) {
+        return {
+            code: 'RPC_INVALID_PARAMS',
+            hint: 'Verify argument names and types for this tool.',
+            retryable: false,
+        };
+    }
+    const httpMatch = message.match(/HTTP (\d{3})/);
+    if (httpMatch) {
+        const status = Number(httpMatch[1]);
+        return {
+            code: 'RPC_HTTP_ERROR',
+            hint: status >= 500
+                ? 'Daemon is reachable but errored; retry after checking node health.'
+                : 'Check DERO_DAEMON_URL and ensure /json_rpc is accessible.',
+            retryable: status >= 500,
+        };
+    }
+    if (message.toLowerCase().includes('fetch failed') ||
+        message.toLowerCase().includes('network') ||
+        message.toLowerCase().includes('econnrefused') ||
+        message.toLowerCase().includes('aborted')) {
+        return {
+            code: 'RPC_UNREACHABLE',
+            hint: 'Confirm daemon is running and reachable, then rerun `npm run doctor`.',
+            retryable: true,
+        };
+    }
+    if (message.includes('Invalid JSON from node')) {
+        return {
+            code: 'RPC_INVALID_RESPONSE',
+            hint: 'Daemon returned malformed JSON. Check reverse proxies or node health.',
+            retryable: true,
+        };
+    }
+    return {
+        code: 'TOOL_EXECUTION_ERROR',
+        hint: 'Retry once, then inspect daemon logs and tool input values.',
+        retryable: false,
+    };
+}
+function toolError(tool, error) {
+    const structured = classifyToolError(error);
+    const raw = error instanceof Error ? error.message : String(error);
+    return toolText({
+        ok: false,
+        tool,
+        _meta: {
+            error: {
+                ...structured,
+                raw,
+            },
+        },
+    });
+}
+function withStructuredErrors(tool, handler) {
+    return async (args) => {
+        try {
+            return toolText(await handler(args));
+        }
+        catch (error) {
+            return toolError(tool, error);
+        }
+    };
+}
 export function createDeroMcpServer(daemonBaseUrl) {
     const endpoint = jsonRpcEndpoint(daemonBaseUrl);
     const rpc = async (method, params) => deroJsonRpc(endpoint, method, params);
@@ -25,30 +142,29 @@ export function createDeroMcpServer(daemonBaseUrl) {
     });
     server.registerTool('dero_daemon_ping', {
         description: 'DERO daemon connectivity check. Calls DERO.Ping. No parameters.',
-    }, async () => toolText(await rpc('DERO.Ping')));
+    }, withStructuredErrors('dero_daemon_ping', async () => rpc('DERO.Ping')));
     server.registerTool('dero_daemon_echo', {
         description: 'Echo strings through the daemon (DERO.Echo).',
         inputSchema: {
             words: z.array(z.string()).describe('Strings to echo back'),
         },
-    }, async ({ words }) => toolText(await rpc('DERO.Echo', words)));
+    }, withStructuredErrors('dero_daemon_echo', async ({ words }) => rpc('DERO.Echo', words)));
     server.registerTool('dero_get_info', {
         description: 'Get daemon / chain info: height, difficulty, version, mempool size, etc. (DERO.GetInfo).',
-    }, async () => toolText(await rpc('DERO.GetInfo')));
+    }, withStructuredErrors('dero_get_info', async () => rpc('DERO.GetInfo')));
     server.registerTool('dero_get_height', {
         description: 'Get top block height and stable/topo heights (DERO.GetHeight).',
-    }, async () => toolText(await rpc('DERO.GetHeight')));
+    }, withStructuredErrors('dero_get_height', async () => rpc('DERO.GetHeight')));
     server.registerTool('dero_get_block_count', {
         description: 'Total block count (DERO.GetBlockCount).',
-    }, async () => toolText(await rpc('DERO.GetBlockCount')));
+    }, withStructuredErrors('dero_get_block_count', async () => rpc('DERO.GetBlockCount')));
     server.registerTool('dero_get_last_block_header', {
         description: 'Header of the tip block (DERO.GetLastBlockHeader).',
-    }, async () => toolText(await rpc('DERO.GetLastBlockHeader')));
+    }, withStructuredErrors('dero_get_last_block_header', async () => rpc('DERO.GetLastBlockHeader')));
     server.registerTool('dero_get_block', {
         description: 'Fetch a full block by height or hash (DERO.GetBlock). Provide one of hash or height.',
         inputSchema: {
-            hash: z
-                .string()
+            hash: hex64Schema
                 .optional()
                 .describe('64-char hex block hash'),
             height: z
@@ -58,7 +174,7 @@ export function createDeroMcpServer(daemonBaseUrl) {
                 .optional()
                 .describe('Block height'),
         },
-    }, async (args) => {
+    }, withStructuredErrors('dero_get_block', async (args) => {
         if (!args.hash && args.height === undefined) {
             throw new Error('Provide either hash or height');
         }
@@ -67,8 +183,8 @@ export function createDeroMcpServer(daemonBaseUrl) {
             params.hash = args.hash;
         if (args.height !== undefined)
             params.height = args.height;
-        return toolText(await rpc('DERO.GetBlock', params));
-    });
+        return rpc('DERO.GetBlock', params);
+    }));
     server.registerTool('dero_get_block_header_by_topo_height', {
         description: 'Block header by topological height (DERO.GetBlockHeaderByTopoHeight).',
         inputSchema: {
@@ -78,30 +194,29 @@ export function createDeroMcpServer(daemonBaseUrl) {
                 .nonnegative()
                 .describe('Topological height'),
         },
-    }, async ({ topoheight }) => toolText(await rpc('DERO.GetBlockHeaderByTopoHeight', { topoheight })));
+    }, withStructuredErrors('dero_get_block_header_by_topo_height', async ({ topoheight }) => rpc('DERO.GetBlockHeaderByTopoHeight', { topoheight })));
     server.registerTool('dero_get_block_header_by_hash', {
         description: 'Block header by hash (DERO.GetBlockHeaderByHash).',
         inputSchema: {
-            hash: z.string().describe('Block top hash (hex)'),
+            hash: hex64Schema.describe('Block top hash (hex)'),
         },
-    }, async ({ hash }) => toolText(await rpc('DERO.GetBlockHeaderByHash', { hash })));
+    }, withStructuredErrors('dero_get_block_header_by_hash', async ({ hash }) => rpc('DERO.GetBlockHeaderByHash', { hash })));
     server.registerTool('dero_get_tx_pool', {
         description: 'Pending mempool transaction hashes (DERO.GetTxPool).',
-    }, async () => toolText(await rpc('DERO.GetTxPool')));
+    }, withStructuredErrors('dero_get_tx_pool', async () => rpc('DERO.GetTxPool')));
     server.registerTool('dero_get_random_address', {
         description: 'Random registered addresses from chain (for ring construction); optional asset scid (DERO.GetRandomAddress).',
         inputSchema: {
-            scid: z
-                .string()
+            scid: hex64Schema
                 .optional()
                 .describe('Optional asset smart-contract id (hex)'),
         },
-    }, async (args) => toolText(await rpc('DERO.GetRandomAddress', args.scid != null ? { scid: args.scid } : undefined)));
+    }, withStructuredErrors('dero_get_random_address', async (args) => rpc('DERO.GetRandomAddress', args.scid != null ? { scid: args.scid } : undefined)));
     server.registerTool('dero_get_transaction', {
         description: 'Fetch transactions by tx hashes (DERO.GetTransaction).',
         inputSchema: {
             txs_hashes: z
-                .array(z.string())
+                .array(hex64Schema)
                 .min(1)
                 .describe('List of transaction hashes (hex)'),
             decode_as_json: z
@@ -110,32 +225,32 @@ export function createDeroMcpServer(daemonBaseUrl) {
                 .optional()
                 .describe('Optional: decode each tx as JSON when non-zero'),
         },
-    }, async ({ txs_hashes, decode_as_json }) => {
+    }, withStructuredErrors('dero_get_transaction', async ({ txs_hashes, decode_as_json }) => {
         const params = { txs_hashes };
         if (decode_as_json !== undefined)
             params.decode_as_json = decode_as_json;
-        return toolText(await rpc('DERO.GetTransaction', params));
-    });
+        return rpc('DERO.GetTransaction', params);
+    }));
     server.registerTool('dero_get_encrypted_balance', {
         description: 'Encrypted balance blob for an address at a topo height (DERO.GetEncryptedBalance). Not cleartext balance.',
         inputSchema: {
-            address: z.string().describe('DERO address (deto1…)'),
+            address: deroAddressSchema.describe('DERO address (dero1… or deto1…)'),
             topoheight: z
                 .number()
                 .int()
                 .describe('Use -1 for latest chain tip'),
-            scid: z.string().optional().describe('Asset SCID hex; omit for native DERO'),
+            scid: hex64Schema.optional().describe('Asset SCID hex; omit for native DERO'),
         },
-    }, async ({ address, topoheight, scid }) => {
+    }, withStructuredErrors('dero_get_encrypted_balance', async ({ address, topoheight, scid }) => {
         const params = { address, topoheight };
         if (scid)
             params.scid = scid;
-        return toolText(await rpc('DERO.GetEncryptedBalance', params));
-    });
+        return rpc('DERO.GetEncryptedBalance', params);
+    }));
     server.registerTool('dero_get_sc', {
         description: 'Read smart contract code and/or variables by SCID (DERO.GetSC).',
         inputSchema: {
-            scid: z.string().describe('64-char hex Smart Contract ID'),
+            scid: hex64Schema.describe('64-char hex Smart Contract ID'),
             code: z
                 .boolean()
                 .optional()
@@ -150,7 +265,7 @@ export function createDeroMcpServer(daemonBaseUrl) {
                 .optional()
                 .describe('Topo height; omit or use -1 for latest'),
         },
-    }, async ({ scid, code, variables, topoheight }) => {
+    }, withStructuredErrors('dero_get_sc', async ({ scid, code, variables, topoheight }) => {
         const params = {
             scid,
             code: code ?? true,
@@ -158,8 +273,8 @@ export function createDeroMcpServer(daemonBaseUrl) {
         };
         if (topoheight !== undefined)
             params.topoheight = topoheight;
-        return toolText(await rpc('DERO.GetSC', params));
-    });
+        return rpc('DERO.GetSC', params);
+    }));
     server.registerTool('dero_get_gas_estimate', {
         description: 'Estimate gas (compute + storage) for transfers, deploy, or SC call (DERO.GetGasEstimate).',
         inputSchema: {
@@ -177,7 +292,7 @@ export function createDeroMcpServer(daemonBaseUrl) {
                 .optional()
                 .describe('Signer address used for estimation'),
         },
-    }, async (args) => {
+    }, withStructuredErrors('dero_get_gas_estimate', async (args) => {
         const params = {};
         if (args.transfers)
             params.transfers = args.transfers;
@@ -187,36 +302,174 @@ export function createDeroMcpServer(daemonBaseUrl) {
             params.sc_rpc = args.sc_rpc;
         if (args.signer)
             params.signer = args.signer;
-        return toolText(await rpc('DERO.GetGasEstimate', params));
-    });
+        return rpc('DERO.GetGasEstimate', params);
+    }));
     server.registerTool('dero_name_to_address', {
         description: 'Resolve a DERO on-chain name to address (DERO.NameToAddress).',
         inputSchema: {
-            name: z.string().describe('Registered name'),
+            name: z.string().min(1).describe('Registered name'),
             topoheight: z
                 .number()
                 .int()
                 .describe('Use -1 for latest'),
         },
-    }, async ({ name, topoheight }) => toolText(await rpc('DERO.NameToAddress', { name, topoheight })));
+    }, withStructuredErrors('dero_name_to_address', async ({ name, topoheight }) => rpc('DERO.NameToAddress', { name, topoheight })));
     server.registerTool('dero_get_block_template', {
         description: 'Mining: get block template for a miner address (DERO.GetBlockTemplate).',
         inputSchema: {
-            wallet_address: z.string().describe('Miner payout DERO address'),
+            wallet_address: deroAddressSchema.describe('Miner payout DERO address'),
             block: z
                 .boolean()
                 .optional()
                 .describe('Include block blob'),
             miner: z.string().optional().describe('Optional miner id / label'),
         },
-    }, async ({ wallet_address, block, miner }) => {
+    }, withStructuredErrors('dero_get_block_template', async ({ wallet_address, block, miner }) => {
         const params = { wallet_address };
         if (block !== undefined)
             params.block = block;
         if (miner)
             params.miner = miner;
-        return toolText(await rpc('DERO.GetBlockTemplate', params));
-    });
+        return rpc('DERO.GetBlockTemplate', params);
+    }));
+    server.registerResource('dero_mcp_server_info', 'dero://mcp/server-info', {
+        description: 'Server metadata, tool list, resource list, and prompt names.',
+        mimeType: 'application/json',
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.toString(),
+                mimeType: 'application/json',
+                text: JSON.stringify({
+                    name: 'dero-daemon-mcp',
+                    version: '0.1.0',
+                    mode: 'read-only',
+                    endpoint: endpoint,
+                    tools: DERO_TOOL_NAMES,
+                    resources: DERO_RESOURCE_URIS,
+                    prompts: DERO_PROMPT_NAMES,
+                }, null, 2),
+            },
+        ],
+    }));
+    server.registerResource('dero_mcp_safety_boundary', 'dero://mcp/safety-boundary', {
+        description: 'Explicit read-only safety boundaries and escalation guidance for write actions.',
+        mimeType: 'application/json',
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.toString(),
+                mimeType: 'application/json',
+                text: JSON.stringify({
+                    read_only: true,
+                    excluded_methods: [
+                        'transfer',
+                        'scinvoke',
+                        'DERO.SendRawTransaction',
+                        'DERO.SubmitBlock',
+                    ],
+                    reasoning: 'These methods can move funds or mutate chain state.',
+                    write_path: [
+                        'Use wallet RPC tooling (curl/XSWD/Engram) for writes.',
+                        'Use dero-mcp-server for live chain reads and analysis.',
+                    ],
+                }, null, 2),
+            },
+        ],
+    }));
+    server.registerResource('dero_mcp_example_flows', 'dero://mcp/example-flows', {
+        description: 'Compact agent flow recipes for common DERO investigations.',
+        mimeType: 'text/markdown',
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.toString(),
+                mimeType: 'text/markdown',
+                text: [
+                    '# DERO MCP Example Flows',
+                    '',
+                    '- Network health: `dero_daemon_ping` -> `dero_get_info` -> `dero_get_height`',
+                    `- Inspect SC state: \`dero_get_sc\` with SCID (name registry: \`${NAME_REGISTRY_SCID}\`)`,
+                    '- Trace transaction: `dero_get_transaction` with `decode_as_json: 1`',
+                    '- Read-only boundary: no wallet writes or raw tx submission',
+                ].join('\n'),
+            },
+        ],
+    }));
+    server.registerPrompt('network_health_check', {
+        description: 'Guide the model through a DERO daemon sync and health check sequence.',
+        argsSchema: {
+            reference_topoheight: z
+                .number()
+                .int()
+                .positive()
+                .optional(),
+        },
+    }, async ({ reference_topoheight }) => ({
+        description: 'Prompt for sync health investigation.',
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        'Check DERO daemon health using MCP tools.',
+                        '1) Call dero_daemon_ping.',
+                        '2) Call dero_get_info and dero_get_height.',
+                        '3) Report topoheight, stableheight, version, and network.',
+                        reference_topoheight
+                            ? `4) Compare topoheight against reference_topoheight=${reference_topoheight}.`
+                            : '4) If no reference topoheight is provided, state that external comparison is still needed for final sync confidence.',
+                    ].join('\n'),
+                },
+            },
+        ],
+    }));
+    server.registerPrompt('inspect_smart_contract', {
+        description: 'Inspect contract code/variables and explain likely state model.',
+        argsSchema: {
+            scid: hex64Schema,
+        },
+    }, async ({ scid }) => ({
+        description: 'Prompt for smart contract inspection.',
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Inspect DERO smart contract ${scid}.`,
+                        '1) Call dero_get_sc with variables=true and code=true.',
+                        '2) Summarize key stringkeys and balances.',
+                        '3) Explain likely data model and any assumptions.',
+                        '4) Include topoheight context from response.',
+                    ].join('\n'),
+                },
+            },
+        ],
+    }));
+    server.registerPrompt('trace_transaction', {
+        description: 'Trace one transaction and summarize confirmation + SC activity.',
+        argsSchema: {
+            tx_hash: hex64Schema,
+        },
+    }, async ({ tx_hash }) => ({
+        description: 'Prompt for transaction tracing.',
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Trace DERO transaction ${tx_hash}.`,
+                        '1) Call dero_get_transaction with txs_hashes=[tx_hash] and decode_as_json=1.',
+                        '2) Summarize confirmation status, block height, transfers, and SC invokes.',
+                        '3) If not confirmed, mention mempool status uncertainty and next check timing.',
+                    ].join('\n'),
+                },
+            },
+        ],
+    }));
     return server;
 }
 //# sourceMappingURL=server.js.map