@hoodag/mcp 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# @hoodag/mcp
+
+An [MCP](https://modelcontextprotocol.io) server for the **.hood** name service on
+[Robinhood Chain](https://hood.ag). It gives an AI agent tools to resolve `.hood` names,
+reverse-resolve addresses, read text records, and check availability & pricing — all as
+read-only on-chain calls (no keys, no writes).
+
+## Run
+
+```bash
+npx @hoodag/mcp
+```
+
+Set `HOOD_RPC_URL` to use your own node (defaults to the public RPC).
+
+## Add to an MCP client
+
+**Claude Desktop / Claude Code** (`claude_desktop_config.json` or `.mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "hood": {
+      "command": "npx",
+      "args": ["-y", "@hoodag/mcp"]
+    }
+  }
+}
+```
+
+**Cursor** (`.cursor/mcp.json`) uses the same shape.
+
+## Tools
+
+| Tool | Input | Returns |
+| --- | --- | --- |
+| `resolve_name` | `name` | address the name points to (or null) |
+| `reverse_resolve` | `address` | primary `.hood` name + `verified` flag |
+| `resolve_text` | `name`, `key` | a text record value (e.g. `com.twitter`) |
+| `check_availability` | `name` | availability + yearly price (wei & USD) |
+| `name_info` | `name` | resolved address, NFT owner, expiry, availability |
+
+The `.hood` suffix is optional on every `name` input.
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/**
+ * @hoodag/mcp — Model Context Protocol server for the .hood name service on Robinhood Chain.
+ *
+ * Gives an AI agent (Claude, Cursor, …) tools to resolve .hood names, reverse-resolve
+ * addresses, read text records, and check availability & pricing.
+ *
+ * Run:  npx @hoodag/mcp
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { createPublicClient, http, keccak256, toBytes, isAddress } from 'viem';
+
+const RPC_URL = process.env.HOOD_RPC_URL || 'https://rpc.mainnet.chain.robinhood.com';
+const YEAR = 365n * 24n * 60n * 60n;
+
+const ADDR = {
+  registrar: '0x9a122C54e15B6287c164b90833bcDA6E16520D50',
+  controller: '0x7900b2B8Cc3f0616B18C68AdA7E115A9022Ca04a',
+  universal: '0xa9ed3C73F522875F18DAa631429125da893D8E53',
+};
+
+const universalAbi = [
+  { type: 'function', name: 'resolve', stateMutability: 'view', inputs: [{ name: 'name', type: 'string' }], outputs: [{ type: 'address' }] },
+  { type: 'function', name: 'reverse', stateMutability: 'view', inputs: [{ name: 'a', type: 'address' }], outputs: [{ name: 'name', type: 'string' }, { name: 'verified', type: 'bool' }] },
+  { type: 'function', name: 'resolveText', stateMutability: 'view', inputs: [{ name: 'name', type: 'string' }, { name: 'key', type: 'string' }], outputs: [{ type: 'string' }] },
+];
+const controllerAbi = [
+  { type: 'function', name: 'available', stateMutability: 'view', inputs: [{ name: 'nm', type: 'string' }], outputs: [{ type: 'bool' }] },
+  { type: 'function', name: 'price', stateMutability: 'view', inputs: [{ name: 'nm', type: 'string' }, { name: 'dur', type: 'uint256' }], outputs: [{ type: 'uint256' }] },
+  { type: 'function', name: 'ethUsd', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+];
+const registrarAbi = [
+  { type: 'function', name: 'ownerOf', stateMutability: 'view', inputs: [{ name: 'id', type: 'uint256' }], outputs: [{ type: 'address' }] },
+  { type: 'function', name: 'nameExpires', stateMutability: 'view', inputs: [{ name: 'id', type: 'uint256' }], outputs: [{ type: 'uint256' }] },
+];
+
+const client = createPublicClient({ transport: http(RPC_URL) });
+
+const ZERO = '0x0000000000000000000000000000000000000000';
+const label = (name) => name.toLowerCase().replace(/\.hood$/, '');
+const fqdn = (name) => (name.toLowerCase().endsWith('.hood') ? name.toLowerCase() : `${label(name)}.hood`);
+const tokenId = (name) => BigInt(keccak256(toBytes(label(name))));
+const usd = (wei, ethUsd) => (!wei || !ethUsd ? null : (Number(wei) / 1e18) * (Number(ethUsd) / 1e18));
+const text = (obj) => ({ content: [{ type: 'text', text: JSON.stringify(obj, null, 2) }] });
+const fail = (msg) => ({ isError: true, content: [{ type: 'text', text: msg }] });
+
+const server = new McpServer({ name: 'hood', version: '0.1.0' });
+
+server.tool(
+  'resolve_name',
+  'Forward-resolve a .hood name to the address it points to. Returns null if unset.',
+  { name: z.string().describe('A .hood name, e.g. "robin.hood" (the .hood suffix is optional).') },
+  async ({ name }) => {
+    try {
+      const addr = await client.readContract({ address: ADDR.universal, abi: universalAbi, functionName: 'resolve', args: [fqdn(name)] });
+      return text({ name: fqdn(name), address: addr === ZERO ? null : addr });
+    } catch (e) { return fail(`resolve failed: ${e.shortMessage || e.message}`); }
+  },
+);
+
+server.tool(
+  'reverse_resolve',
+  'Reverse-resolve an address to its primary .hood name. `verified` is true only when the name\'s forward record points back to the address.',
+  { address: z.string().describe('A 0x wallet address.') },
+  async ({ address }) => {
+    if (!isAddress(address)) return fail('not a valid address');
+    try {
+      const [name, verified] = await client.readContract({ address: ADDR.universal, abi: universalAbi, functionName: 'reverse', args: [address] });
+      return text({ address, name: name || null, verified });
+    } catch (e) { return fail(`reverse failed: ${e.shortMessage || e.message}`); }
+  },
+);
+
+server.tool(
+  'resolve_text',
+  'Read a text record (e.g. "avatar", "url", "com.twitter") set on a .hood name.',
+  { name: z.string().describe('A .hood name.'), key: z.string().describe('Text record key, e.g. "com.twitter".') },
+  async ({ name, key }) => {
+    try {
+      const value = await client.readContract({ address: ADDR.universal, abi: universalAbi, functionName: 'resolveText', args: [fqdn(name), key] });
+      return text({ name: fqdn(name), key, value: value || null });
+    } catch (e) { return fail(`resolveText failed: ${e.shortMessage || e.message}`); }
+  },
+);
+
+server.tool(
+  'check_availability',
+  'Check whether a .hood name is available to register, and its yearly price.',
+  { name: z.string().describe('The name to check (with or without .hood).') },
+  async ({ name }) => {
+    const nm = label(name);
+    try {
+      const [available, priceWei, ethUsd] = await Promise.all([
+        client.readContract({ address: ADDR.controller, abi: controllerAbi, functionName: 'available', args: [nm] }),
+        client.readContract({ address: ADDR.controller, abi: controllerAbi, functionName: 'price', args: [nm, YEAR] }).catch(() => null),
+        client.readContract({ address: ADDR.controller, abi: controllerAbi, functionName: 'ethUsd', args: [] }).catch(() => null),
+      ]);
+      const priceUsd = usd(priceWei, ethUsd);
+      return text({ name: `${nm}.hood`, available, priceWeiPerYear: priceWei ? priceWei.toString() : null, priceUsdPerYear: priceUsd ? Math.round(priceUsd * 100) / 100 : null });
+    } catch (e) { return fail(`availability check failed: ${e.shortMessage || e.message}`); }
+  },
+);
+
+server.tool(
+  'name_info',
+  'Full snapshot of a .hood name: the address it resolves to, the NFT owner, expiry, and availability.',
+  { name: z.string().describe('A .hood name.') },
+  async ({ name }) => {
+    const nm = label(name);
+    const id = tokenId(name);
+    try {
+      const [addr, available, owner, expires] = await Promise.all([
+        client.readContract({ address: ADDR.universal, abi: universalAbi, functionName: 'resolve', args: [`${nm}.hood`] }).catch(() => ZERO),
+        client.readContract({ address: ADDR.controller, abi: controllerAbi, functionName: 'available', args: [nm] }).catch(() => null),
+        client.readContract({ address: ADDR.registrar, abi: registrarAbi, functionName: 'ownerOf', args: [id] }).catch(() => null),
+        client.readContract({ address: ADDR.registrar, abi: registrarAbi, functionName: 'nameExpires', args: [id] }).catch(() => null),
+      ]);
+      return text({
+        name: `${nm}.hood`,
+        resolvesTo: addr === ZERO ? null : addr,
+        nftOwner: owner,
+        expires: expires ? new Date(Number(expires) * 1000).toISOString() : null,
+        available,
+      });
+    } catch (e) { return fail(`name_info failed: ${e.shortMessage || e.message}`); }
+  },
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`[hood-mcp] connected · RPC ${RPC_URL}`);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@hoodag/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for the .hood name service on Robinhood Chain — lets AI agents resolve names, reverse-resolve addresses, read records, and check availability.",
+  "type": "module",
+  "bin": {
+    "hood-mcp": "./index.js"
+  },
+  "main": "./index.js",
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "hood",
+    "ens",
+    "robinhood-chain",
+    "name-service",
+    "ai-agents",
+    "web3"
+  ],
+  "homepage": "https://hood.ag",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "viem": "^2.31.0",
+    "zod": "^3.23.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}