web3-tools-mcp 1.5.0 → 2.0.0

package/src/client.ts

@@ -1,278 +1,65 @@
-import { http, createPublicClient } from 'viem'
-import {
-  arbitrum,
-  avalanche,
-  base,
-  bsc,
-  gnosis,
-  linea,
-  localhost,
-  mainnet,
-  optimism,
-  polygon,
-  sonic,
-  unichain,
-  zksync
-} from 'viem/chains'
-import type { ChainName, Config } from './types.js'
+import { createPublicClient, http } from 'viem'
+import { CHAINS, type ChainName } from './chains.js'
+import type { Config } from './types.js'
 
-// Enhanced RPC configuration with API keys
-function getRpcUrl(chainName: string, config: Config): string {
-  // Check for custom RPC URLs first
-  if (config.customRpcUrls?.[chainName]) {
-    return config.customRpcUrls[chainName]
-  }
-
-  // Enhanced RPC URLs with API keys
-  const enhancedRpcs: Record<string, string> = {
-    mainnet: config.alchemyApiKey
-      ? `https://eth-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://ethereum-rpc.publicnode.com',
-
-    base: config.alchemyApiKey
-      ? `https://base-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : 'https://base-rpc.publicnode.com',
-
-    arbitrum: config.alchemyApiKey
-      ? `https://arb-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://arbitrum-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://arb1.arbitrum.io/rpc',
-
-    polygon: config.alchemyApiKey
-      ? `https://polygon-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://polygon-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://polygon-rpc.com',
-
-    optimism: config.alchemyApiKey
-      ? `https://opt-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://optimism-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://mainnet.optimism.io',
-
-    avalanche: config.alchemyApiKey
-      ? `https://avax-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://avalanche-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://api.avax.network/ext/bc/C/rpc',
+export { SUPPORTED_CHAINS } from './chains.js'
 
-    bnb: config.alchemyApiKey
-      ? `https://bnb-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://bsc-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://bsc-dataseed.bnbchain.org',
+/** Custom URL first, then whichever provider key is configured, then the public endpoint. */
+function getRpcUrl(chainName: ChainName, config: Config): string {
+  const custom = config.customRpcUrls?.[chainName]
+  if (custom) return custom
 
-    gnosis: config.alchemyApiKey
-      ? `https://gnosis-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : 'https://rpc.gnosischain.com',
-
-    sonic: config.alchemyApiKey
-      ? `https://sonic-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : 'https://rpc.soniclabs.com',
-
-    zksync: config.alchemyApiKey
-      ? `https://zksync-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://zksync-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://mainnet.era.zksync.io',
-
-    linea: config.alchemyApiKey
-      ? `https://linea-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://linea-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://rpc.linea.build',
-
-    unichain: config.alchemyApiKey
-      ? `https://unichain-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
-      : config.infuraApiKey
-        ? `https://unichain-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://sepolia.unichain.org',
-
-    localhost: 'http://localhost:8545'
-  }
-
-  return enhancedRpcs[chainName] ?? 'https://eth.llamarpc.com'
+  const { alchemy, infura, fallback } = CHAINS[chainName]
+  if (alchemy && config.alchemyApiKey) return `https://${alchemy}.g.alchemy.com/v2/${config.alchemyApiKey}`
+  if (infura && config.infuraApiKey) return `https://${infura}.infura.io/v3/${config.infuraApiKey}`
+  return fallback
 }
 
-// Supported chains with their RPC endpoints (now dynamic)
-export const CHAINS = (config: Config) => ({
-  mainnet: {
-    chain: mainnet,
-    get rpc() {
-      return getRpcUrl('mainnet', config)
-    }
-  },
-  base: {
-    chain: base,
-    get rpc() {
-      return getRpcUrl('base', config)
-    }
-  },
-  arbitrum: {
-    chain: arbitrum,
-    get rpc() {
-      return getRpcUrl('arbitrum', config)
-    }
-  },
-  polygon: {
-    chain: polygon,
-    get rpc() {
-      return getRpcUrl('polygon', config)
-    }
-  },
-  optimism: {
-    chain: optimism,
-    get rpc() {
-      return getRpcUrl('optimism', config)
-    }
-  },
-  avalanche: {
-    chain: avalanche,
-    get rpc() {
-      return getRpcUrl('avalanche', config)
-    }
-  },
-  bnb: {
-    chain: bsc,
-    get rpc() {
-      return getRpcUrl('bnb', config)
-    }
-  },
-  gnosis: {
-    chain: gnosis,
-    get rpc() {
-      return getRpcUrl('gnosis', config)
-    }
-  },
-  sonic: {
-    chain: sonic,
-    get rpc() {
-      return getRpcUrl('sonic', config)
-    }
-  },
-  zksync: {
-    chain: zksync,
-    get rpc() {
-      return getRpcUrl('zksync', config)
-    }
-  },
-  linea: {
-    chain: linea,
-    get rpc() {
-      return getRpcUrl('linea', config)
-    }
-  },
-  unichain: {
-    chain: unichain,
-    get rpc() {
-      return getRpcUrl('unichain', config)
-    }
-  },
-  localhost: {
-    chain: localhost,
-    get rpc() {
-      return getRpcUrl('localhost', config)
-    }
-  }
-})
+/** Named so declaration emit can refer to it: node_modules is hoisted above this package. */
+type PublicClient = ReturnType<typeof createPublicClient>
 
-// Hypersync URLs for supported chains (localhost is not supported)
-export const HYPERSYNC_URLS: Partial<Record<ChainName, string>> = {
-  mainnet: 'https://eth.hypersync.xyz', // Chain ID 1
-  arbitrum: 'https://arbitrum.hypersync.xyz', // Chain ID 42161
-  avalanche: 'https://avalanche.hypersync.xyz', // Chain ID 43114
-  base: 'https://base.hypersync.xyz', // Chain ID 8453
-  bnb: 'https://bsc.hypersync.xyz', // Chain ID 56
-  gnosis: 'https://gnosis.hypersync.xyz', // Chain ID 100
-  sonic: 'https://sonic.hypersync.xyz', // Chain ID 146
-  optimism: 'https://optimism.hypersync.xyz', // Chain ID 10
-  polygon: 'https://polygon.hypersync.xyz', // Chain ID 137
-  zksync: 'https://zksync.hypersync.xyz', // Chain ID 324
-  linea: 'https://linea.hypersync.xyz', // Chain ID 59144
-  unichain: 'https://unichain.hypersync.xyz' // Chain ID 130
-  // localhost is not supported by hypersync
-}
+export class ClientManager {
+  private clients = new Map<ChainName, PublicClient>()
 
-export const SUPPORTED_CHAINS = [
-  'mainnet',
-  'arbitrum',
-  'avalanche',
-  'base',
-  'bnb',
-  'gnosis',
-  'sonic',
-  'optimism',
-  'polygon',
-  'zksync',
-  'linea',
-  'unichain',
-  'localhost'
-] as const
+  constructor(private config: Config) {}
 
-// Client manager
-export class ClientManager {
-  private clients: Map<ChainName, unknown> = new Map()
-  private config: Config
+  getClient(chainName: ChainName): PublicClient {
+    const cached = this.clients.get(chainName)
+    if (cached) return cached
 
-  constructor(config: Config) {
-    this.config = config
-  }
+    // Cast because a client built for a concrete chain is not assignable to the generic one.
+    const client = createPublicClient({
+      chain: CHAINS[chainName].chain,
+      transport: http(this.getRpcUrl(chainName))
+    }) as PublicClient
 
-  getClient(chainName: ChainName) {
-    if (!this.clients.has(chainName)) {
-      const chains = CHAINS(this.config)
-      const { chain, rpc } = chains[chainName]
-      const client = createPublicClient({
-        chain,
-        transport: http(rpc)
-      })
-      this.clients.set(chainName, client)
-    }
-    const client = this.clients.get(chainName)
-    if (!client) {
-      throw new Error(`Failed to create client for chain: ${chainName}`)
-    }
-    return client as ReturnType<typeof createPublicClient>
+    this.clients.set(chainName, client)
+    return client
   }
 
   getConfig(): Config {
     return this.config
   }
 
-  getEtherscanDomain(chainName: ChainName): string {
-    const domains: Record<ChainName, string> = {
-      mainnet: 'etherscan.io',
-      base: 'basescan.org',
-      arbitrum: 'arbiscan.io',
-      polygon: 'polygonscan.com',
-      optimism: 'optimistic.etherscan.io',
-      avalanche: 'snowtrace.io',
-      bnb: 'bscscan.com',
-      gnosis: 'gnosisscan.io',
-      sonic: 'sonicscan.org',
-      zksync: 'era.zksync.network',
-      linea: 'lineascan.build',
-      unichain: 'uniscan.xyz',
-      localhost: 'etherscan.io'
-    }
-    return domains[chainName] || 'etherscan.io'
-  }
-
   getRpcUrl(chainName: ChainName): string {
-    const chains = CHAINS(this.config)
-    return chains[chainName].rpc
+    return getRpcUrl(chainName, this.config)
   }
 
   getChainId(chainName: ChainName): number {
-    const chains = CHAINS(this.config)
-    return chains[chainName].chain.id
+    return CHAINS[chainName].chain.id
+  }
+
+  getHypersyncUrl(chainName: ChainName): string | undefined {
+    return CHAINS[chainName].hypersync
+  }
+
+  /** Undefined where the chain has no explorer — a local node, for one. */
+  explorerUrl(chainName: ChainName, path = ''): string | undefined {
+    const domain = CHAINS[chainName].explorer
+    return domain ? `https://${domain}${path}` : undefined
   }
 }
 
-// Export a global client manager instance
 let clientManager: ClientManager | null = null
 
 export function initializeClientManager(config: Config): ClientManager {

package/src/http-server.ts

@@ -0,0 +1,117 @@
+import { requireBearerAuth } from '@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js'
+import { getOAuthProtectedResourceMetadataUrl, mcpAuthRouter } from '@modelcontextprotocol/sdk/server/auth/router.js'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
+import express from 'express'
+import type { WalletRelay } from 'web3-wallet-relay'
+import { SingleUserOAuthProvider } from './oauth.js'
+
+/**
+ * Serve the MCP over HTTP instead of stdio, so the server can live somewhere other than the
+ * machine running the agent. Signing still reaches you: a paired phone over WalletConnect,
+ * or the signing page, which is mounted on this same server so one platform port carries
+ * both it and /mcp.
+ *
+ * Two ways in, because clients differ: a static `Authorization: Bearer <MCP_TOKEN>` header
+ * (Claude Code), and the OAuth flow the MCP spec defines (claude.ai connectors, which offer
+ * no way to send a header). Both end up at the same single credential.
+ *
+ * Stateless — a server per request — because every tool here is a one-shot call and the
+ * signing state lives in the WalletConnect session, not in the transport.
+ */
+
+const DEFAULT_PORT = 3457
+
+export interface HttpServerOptions {
+  port?: number
+  host?: string
+  token?: string
+  /** Public URL clients reach this server on; OAuth metadata must advertise it. */
+  publicUrl?: string
+  /** Serve the signing page on this same server, so browser signing works when hosted. */
+  walletRelay?: WalletRelay
+  createMcpServer: () => McpServer
+}
+
+export async function startHttpServer(options: HttpServerOptions): Promise<{ url: string; port: number; walletUrl?: string }> {
+  const port = options.port ?? Number(process.env.MCP_HTTP_PORT) ?? DEFAULT_PORT
+  const host = options.host ?? process.env.MCP_HTTP_HOST ?? '0.0.0.0'
+  const token = options.token ?? process.env.MCP_TOKEN
+
+  // A reachable MCP server with a paired phone can push signing prompts at that phone. It
+  // never runs without a token.
+  if (!token) {
+    throw new Error('MCP_TOKEN is required to serve MCP over HTTP — anyone reaching the URL could request signatures')
+  }
+
+  const publicUrl = options.publicUrl ?? process.env.MCP_PUBLIC_URL ?? `http://localhost:${port}`
+  const issuer = new URL(publicUrl)
+  const provider = new SingleUserOAuthProvider(token)
+
+  const app = express()
+  app.use(express.json())
+  // The login form posts a token, so the authorize route needs form bodies too.
+  app.use(express.urlencoded({ extended: false }))
+
+  app.get('/health', (_req, res) => {
+    res.json({ status: 'ok' })
+  })
+
+  // /authorize, /token, /register, /revoke and the metadata documents a client discovers
+  // after a 401.
+  app.use(
+    mcpAuthRouter({
+      provider,
+      issuerUrl: issuer,
+      baseUrl: issuer,
+      resourceServerUrl: new URL('/mcp', issuer),
+      resourceName: 'web3-tools-mcp',
+      scopesSupported: []
+    })
+  )
+
+  // The metadata document is mounted under the resource path, so the 401 has to advertise
+  // that exact URL — a bare /.well-known/oauth-protected-resource 404s, and a client that
+  // follows it gives up right where discovery should have started.
+  const authenticate = requireBearerAuth({
+    verifier: provider,
+    resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(new URL('/mcp', issuer))
+  })
+
+  app.all('/mcp', authenticate, async (req, res) => {
+    const mcp = options.createMcpServer()
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true })
+
+    res.on('close', () => {
+      transport.close().catch(() => {})
+      mcp.close().catch(() => {})
+    })
+
+    try {
+      await mcp.connect(transport)
+      await transport.handleRequest(req, res, req.body)
+    } catch (error) {
+      console.error('[MCP] Request failed:', error)
+      if (!res.headersSent) {
+        res.status(500).json({ jsonrpc: '2.0', error: { code: -32603, message: 'Internal error' } })
+      }
+    }
+  })
+
+  const server = await new Promise<ReturnType<typeof app.listen>>((resolve, reject) => {
+    const listening = app.listen(port, host, () => resolve(listening))
+    listening.once('error', reject)
+  })
+
+  // The signing page rides on this same server, so a hosted deployment can offer browser
+  // signing without a second service: one platform port serves both /mcp and the page.
+  // Mounted last, so the routes above keep their paths — the relay only claims what is
+  // left, which is the static page at the root.
+  let walletUrl: string | undefined
+  if (options.walletRelay) {
+    options.walletRelay.attach(server, (relayApp) => app.use(relayApp))
+    walletUrl = `${publicUrl.replace(/\/$/, '')}/#t=${options.walletRelay.token}`
+  }
+
+  return { url: `${publicUrl.replace(/\/$/, '')}/mcp`, port: (server.address() as { port: number }).port, walletUrl }
+}

package/src/index.ts

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 
-import packageJson from "../package.json" with { type: "json" };
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { initializeClientManager } from "./client.js";
-import { registerAllTools } from "./tools/index.js";
-import { parseCommandLineArgs } from "./utils.js";
-import { getWalletClient } from "./wallet-client.js";
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { WalletRelay } from 'web3-wallet-relay'
+import packageJson from '../package.json' with { type: 'json' }
+import { initializeClientManager, SUPPORTED_CHAINS } from './client.js'
+import { startHttpServer } from './http-server.js'
+import { registerAllTools } from './tools/index.js'
+import { parseCommandLineArgs } from './utils.js'
+import { getWalletClient } from './wallet-client.js'
 
 // Parse configuration
-const config = parseCommandLineArgs();
+const config = parseCommandLineArgs()
 
 // Show help if requested
 if (config.showHelp) {
@@ -26,6 +28,8 @@ OPTIONS:
   --alchemy-api-key <key>       Alchemy API key (for enhanced RPC)
   --infura-api-key <key>        Infura API key (for alternative RPC)
   --hypersync-api-key <key>     Hypersync API key (for fast event queries)
+  --walletconnect-project-id <id>
+                                WalletConnect project id, to sign from a phone
   --custom-rpc <json>           Custom RPC URLs as JSON object
                                 Example: '{"mainnet":"https://...", "base":"https://..."}'
 
@@ -34,11 +38,18 @@ ENVIRONMENT VARIABLES:
   ALCHEMY_API_KEY               Alternative to --alchemy-api-key
   INFURA_API_KEY                Alternative to --infura-api-key
   HYPERSYNC_API_KEY             Alternative to --hypersync-api-key
+  WALLETCONNECT_PROJECT_ID      Alternative to --walletconnect-project-id
+  CUSTOM_RPC                    Alternative to --custom-rpc
+  MCP_HTTP_PORT                 Serve MCP over HTTP on this port instead of stdio
+  MCP_TOKEN                     Bearer token required by the HTTP transport
+  MCP_PUBLIC_URL                Public URL of this server, advertised in OAuth metadata
+  UPSTASH_REDIS_REST_URL        Keep WalletConnect sessions in Redis, not on disk
+  UPSTASH_REDIS_REST_TOKEN
   WALLET_SERVER_URL             URL of a hosted wallet relay (omit to run one locally)
   WALLET_TOKEN                  Shared pairing token for the wallet relay
 
 SUPPORTED CHAINS:
-  mainnet, arbitrum, avalanche, base, bnb, gnosis, sonic, optimism, polygon, zksync, linea, unichain, localhost
+  ${SUPPORTED_CHAINS.join(', ')}
 
 EXAMPLES:
   # Use with npx (recommended)
@@ -56,70 +67,108 @@ DOCUMENTATION:
   Issues: ${packageJson.bugs.url}
 
 For MCP client configuration, see the README.md file.
-`);
-  process.exit(0);
+`)
+  process.exit(0)
 }
 
 // Log configuration info
 if (config.etherscanApiKey) {
-  console.error("[MCP] Etherscan API key configured");
+  console.error('[MCP] Etherscan API key configured')
 }
 if (config.alchemyApiKey) {
-  console.error("[MCP] Alchemy API key configured");
+  console.error('[MCP] Alchemy API key configured')
 }
 if (config.infuraApiKey) {
-  console.error("[MCP] Infura API key configured");
+  console.error('[MCP] Infura API key configured')
+}
+if (config.walletConnectProjectId) {
+  console.error('[MCP] WalletConnect project id configured — phone signing available')
 }
 if (config.customRpcUrls) {
-  console.error("[MCP] Custom RPC URLs:", Object.keys(config.customRpcUrls));
+  console.error('[MCP] Custom RPC URLs:', Object.keys(config.customRpcUrls))
 }
 
 // Initialize client manager
-initializeClientManager(config);
-
-// Create MCP server instance
-const server = new McpServer({
-  name: "web3-tools-mcp",
-  version: packageJson.version,
-});
-
-// Register all tools
-registerAllTools(server);
+initializeClientManager(config)
+
+function createMcpServer() {
+  const server = new McpServer({
+    name: 'web3-tools-mcp',
+    version: packageJson.version
+  })
+  registerAllTools(server)
+  return server
+}
 
-// Connect to the wallet relay (hosted when WALLET_SERVER_URL is set, embedded otherwise)
-const wallet = getWalletClient();
-const walletReady = wallet.connect().catch((error) => {
-  console.error("[MCP] Wallet relay unavailable:", error.message);
-  console.error("[MCP] Transaction signing features will not be available");
-});
+const httpMode = Boolean(process.env.MCP_HTTP_PORT)
+const httpPort = Number(process.env.MCP_HTTP_PORT)
+
+/**
+ * Hosted, the signing page rides on the same port as /mcp, so a browser wallet works from
+ * a deployment too — the platform gives one port and both fit on it.
+ *
+ * Its token is minted per boot rather than persisted. A hosted relay is reachable from
+ * anywhere, and the pairing URL is fetched through wallet_status, which already needs
+ * MCP_TOKEN — so nobody types this token, and a short-lived one costs nothing. Locally the
+ * token stays on disk, because several editor sessions have to find the same relay.
+ */
+const hostedRelay = httpMode
+  ? new WalletRelay({ token: process.env.WALLET_TOKEN, publicUrl: process.env.MCP_PUBLIC_URL })
+  : undefined
+
+const wallet = getWalletClient(hostedRelay ? { port: httpPort, token: hostedRelay.token } : undefined)
+
+// Hosted, the relay is attached to the HTTP server, so connect only once that is listening.
+const walletReady = httpMode
+  ? Promise.resolve()
+  : wallet.connect().catch((error) => {
+      console.error('[MCP] Wallet relay unavailable:', error.message)
+      console.error('[MCP] Transaction signing features will not be available')
+    })
 
 // The wallet relay's listening socket keeps the event loop alive, so this process would
 // outlive the client that spawned it and go on holding its port. Leave when the client does.
-let shuttingDown = false;
+let shuttingDown = false
 async function shutdown(reason: string) {
-  if (shuttingDown) return;
-  shuttingDown = true;
-  console.error(`[MCP] Shutting down (${reason})`);
-  await wallet.stop().catch(() => {});
-  process.exit(0);
+  if (shuttingDown) return
+  shuttingDown = true
+  console.error(`[MCP] Shutting down (${reason})`)
+  await wallet.stop().catch(() => {})
+  process.exit(0)
 }
 
-process.stdin.on("end", () => shutdown("client disconnected"));
-process.stdin.on("close", () => shutdown("client disconnected"));
-process.on("SIGTERM", () => shutdown("SIGTERM"));
-process.on("SIGINT", () => shutdown("SIGINT"));
+process.stdin.on('end', () => shutdown('client disconnected'))
+process.stdin.on('close', () => shutdown('client disconnected'))
+process.on('SIGTERM', () => shutdown('SIGTERM'))
+process.on('SIGINT', () => shutdown('SIGINT'))
 
 // Start server
 async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error("Web3 Tools MCP Server running on stdio");
+  if (httpMode) {
+    const { url, walletUrl } = await startHttpServer({ createMcpServer, walletRelay: hostedRelay })
+    console.error(`Web3 Tools MCP Server listening on ${url}`)
+
+    // Join the relay now that it is listening, so browser signing is available here too.
+    await wallet.connect().catch((error) => {
+      console.error('[MCP] Could not join the wallet relay:', error.message)
+    })
+    if (walletUrl) console.error(`Wallet interface available at ${walletUrl}`)
+
+    if (!config.walletConnectProjectId) {
+      console.error('[MCP] No WalletConnect project id — phone signing is unavailable on this server')
+    }
+    return
+  }
+
+  const transport = new StdioServerTransport()
+  await createMcpServer().connect(transport)
+  console.error('Web3 Tools MCP Server running on stdio')
   // The relay may still be picking a free port, and its URL carries the pairing token.
-  await walletReady;
-  console.error(`Wallet interface available at ${wallet.getUrl()}`);
+  await walletReady
+  console.error(`Wallet interface available at ${wallet.getUrl()}`)
 }
 
 main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
-});
+  console.error('Fatal error:', error)
+  process.exit(1)
+})