@veyanet/mcp 1.0.0

package/src/tools/public.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MCP_SERVICE_NAME, MCP_SERVICE_VERSION, type McpServiceConfig } from "../config.js";
+import { createReadClient } from "../sdk.js";
+
+export function registerPublicTools(server: McpServer, cfg: McpServiceConfig): void {
+  server.tool(
+    "veya_describe",
+    "Honesty card: what this MCP is (AES sealed elsewhere, testnet 46630, not FHE/mainnet)",
+    {},
+    async () => ({
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              name: MCP_SERVICE_NAME,
+              version: MCP_SERVICE_VERSION,
+              publicUrl: cfg.publicMcpUrl,
+              settlement: {
+                network: "Robinhood Chain testnet",
+                chainId: cfg.chainId,
+                contract: cfg.contractAddress,
+                explorer: cfg.explorerUrl,
+                rpc: cfg.rpcUrl,
+              },
+              productApi: cfg.apiUrl,
+              sealed: "AES-256-GCM sealed-node (not FHE; TFHE is Phase 4)",
+              mainnet: "Not a VEYA settlement claim (Phase 3)",
+              writes: "Require Authorization: Bearer <MCP_API_KEY> when enabled on the server",
+              stdioSibling: "Local stdio MCP remains at veya-anchor/packages/mcp (operators)",
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    }),
+  );
+
+  server.tool(
+    "veya_ping_chain",
+    "Ping Robinhood Chain RPC — chain id, block, contract",
+    {},
+    async () => {
+      const client = createReadClient(cfg);
+      const ping = await client.pingChain();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                ...ping,
+                chainId: ping.chainId.toString(),
+                expectedChainId: cfg.chainId,
+                config: client.describe(),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    },
+  );
+
+  server.tool(
+    "veya_hash_blake3",
+    "Compute BLAKE3 hex digest (commitment helper)",
+    { data: z.string().min(1) },
+    async ({ data }) => {
+      const client = createReadClient(cfg);
+      const hash = await client.hashBlake3(data);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ hash }, null, 2) }],
+      };
+    },
+  );
+
+  server.tool(
+    "veya_verify_transaction",
+    "Verify a Veya.sol commitment from a Robinhood Chain tx hash",
+    { txHash: z.string().min(66) },
+    async ({ txHash }) => {
+      const client = createReadClient(cfg);
+      const result = await client.verifyTransaction(txHash);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    },
+  );
+
+  server.tool(
+    "veya_api_health",
+    "Probe the public VEYA API /health (api.veyanet.tech) — honest degraded when fleet down",
+    {},
+    async () => {
+      const res = await fetch(`${cfg.apiUrl}/health`, {
+        signal: AbortSignal.timeout(8000),
+      });
+      const body = await res.json().catch(() => ({}));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ httpStatus: res.status, body }, null, 2),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/tools/write.ts

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpServiceConfig } from "../config.js";
+import { writesEnabled } from "../config.js";
+import { assertWriteAuthorized } from "../auth.js";
+import { createWriteClient, parseHexBytes } from "../sdk.js";
+
+/**
+ * Write tools are registered only when MCP_API_KEY + relayer key exist.
+ * Callers must still pass Authorization: Bearer on the HTTP request;
+ * bearer is read from request AsyncLocalStorage.
+ */
+export function registerWriteTools(
+  server: McpServer,
+  cfg: McpServiceConfig,
+  getBearer: () => string | null,
+): void {
+  if (!writesEnabled(cfg)) {
+    server.tool(
+      "veya_writes_status",
+      "Reports that on-chain write tools are disabled on this server",
+      {},
+      async () => ({
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              writesEnabled: false,
+              reason: "Set MCP_API_KEY and VEYA_RELAYER_PRIVATE_KEY to enable write tools",
+            }),
+          },
+        ],
+      }),
+    );
+    return;
+  }
+
+  function requireAuth(): void {
+    assertWriteAuthorized(cfg, getBearer());
+  }
+
+  server.tool(
+    "veya_store_commitment",
+    "Write a 32-byte commitment to Veya.sol (requires MCP_API_KEY). Use content Use stamps prefer product-site + API.",
+    {
+      environmentUuidHex: z.string().min(32),
+      commitmentHex: z.string().min(64),
+    },
+    async ({ environmentUuidHex, commitmentHex }) => {
+      requireAuth();
+      const client = createWriteClient(cfg);
+      const txHash = await client.requireEvm().storeCommitment(
+        parseHexBytes(environmentUuidHex, 16),
+        parseHexBytes(commitmentHex, 32),
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ txHash, explorer: client.explorerFor(txHash) }, null, 2),
+          },
+        ],
+      };
+    },
+  );
+
+  server.tool(
+    "veya_attest_execution",
+    "attestExecution on Veya.sol with ML-DSA bytes (requires MCP_API_KEY)",
+    {
+      environmentUuidHex: z.string().min(32),
+      blake3HashHex: z.string().min(64),
+      mldsaSigHex: z.string().min(8),
+    },
+    async ({ environmentUuidHex, blake3HashHex, mldsaSigHex }) => {
+      requireAuth();
+      const client = createWriteClient(cfg);
+      const txHash = await client.requireEvm().attestExecution(
+        parseHexBytes(environmentUuidHex, 16),
+        parseHexBytes(blake3HashHex, 32),
+        parseHexBytes(mldsaSigHex),
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ txHash, explorer: client.explorerFor(txHash) }, null, 2),
+          },
+        ],
+      };
+    },
+  );
+
+  server.tool(
+    "veya_register_environment",
+    "registerEnvironment on Veya.sol (requires MCP_API_KEY)",
+    {
+      environmentUuidHex: z.string().min(32),
+      pqPubkeyHashHex: z.string().min(64),
+      envType: z.number().int().min(0).max(10).default(0),
+    },
+    async ({ environmentUuidHex, pqPubkeyHashHex, envType }) => {
+      requireAuth();
+      const client = createWriteClient(cfg);
+      const txHash = await client.requireEvm().registerEnvironment(
+        parseHexBytes(environmentUuidHex, 16),
+        parseHexBytes(pqPubkeyHashHex, 32),
+        envType,
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ txHash, explorer: client.explorerFor(txHash) }, null, 2),
+          },
+        ],
+      };
+    },
+  );
+}