fix: enforce exact amounts and browser MCP interoperability

Author: ccbbccbb

README.md

@@ -270,6 +270,8 @@ The HTTP server uses the following default configuration:
 
 When binding to a non-local interface, explicitly configure the public hostnames accepted by `MCP_ALLOWED_HOSTS` and `MCP_ALLOWED_ORIGINS`. Values may be hostnames or origin URLs; validation is port-agnostic.
 
+Allowed browser origins receive CORS headers on responses, including OAuth challenges and discovery metadata. Preflight requests are validated before authentication; actual MCP requests still require the configured bearer scopes. CORS permits GET/POST, standard MCP headers, authorization, and annotated `Mcp-Param-*` headers. Cookies are not enabled.
+
 #### HTTP OAuth
 
 The HTTP process is an OAuth resource server; it does not issue access tokens. OAuth is optional only when `MCP_HOST` is local (`127.0.0.1`, `localhost`, or `::1`). If `MCP_OAUTH_ISSUER_URL` is set, OAuth is enabled even for a local bind. A non-local bind fails during startup unless OAuth is fully configured.
@@ -351,6 +353,8 @@ bun dev:http
 
 Connect to this MCP server using any MCP-compatible client. For testing and debugging, you can use the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).
 
+Run `bun run inspect` for the Inspector UI, or `bun run inspect:check` for strict tool-schema checks. Both build the stdio server and use `mcp-inspector.json` with explicit modern protocol negotiation. Inspector requires Node >=22.19.0 and is pinned to the verified 2.5.0 release. To inspect HTTP, start `bun run start:http` separately and select `evm-http`; adjust the config URL if using a different port.
+
 ### Connecting from Cursor
 
 To connect to the MCP server from Cursor:
@@ -576,6 +580,8 @@ The following wallet-backed tools enforce confirmation through MCP multi-round-t
 
 The first invocation describes the exact operation and requests a boolean `confirm` input. No wallet action occurs until the client returns an accepted response with `confirm: true`; declining or cancelling terminates the operation. Clients should display this protocol-level request instead of adding a separate conversational confirmation.
 
+Amounts must be non-negative decimal strings exactly representable in the asset's base units; excess nonzero decimal places are rejected before confirmation. Token precision is read before each confirmation round, and the confirmation binds both decimals and the exact base-unit amount. A precision change requires fresh confirmation. Execution uses the confirmed base units without another decimals lookup.
+
 Confirmation continuation state is HMAC integrity-protected and binds the complete tool arguments. It expires after five minutes, is process-local and single-use, and is also bound to the authenticated bearer token for HTTP requests. An expired, replayed, cross-process, or differently authenticated continuation requires a new confirmation.
 
 For example, the initial transfer call uses ordinary `tools/call` parameters:

mcp-inspector.json

@@ -0,0 +1,15 @@
+{
+  "mcpServers": {
+    "evm-stdio": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["bin/cli.js"],
+      "protocolEra": "modern"
+    },
+    "evm-http": {
+      "type": "streamable-http",
+      "url": "http://127.0.0.1:3001/mcp",
+      "protocolEra": "modern"
+    }
+  }
+}

package.json

@@ -27,7 +27,8 @@
     "release": "npm publish",
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
     "changelog:latest": "conventional-changelog -p angular -r 1 > RELEASE_NOTES.md",
-    "inspect": "npx @modelcontextprotocol/inspector node build/index.js",
+    "inspect": "bun run build && npx -y @modelcontextprotocol/inspector@2.5.0 --config mcp-inspector.json",
+    "inspect:check": "bun run build && npx -y @modelcontextprotocol/inspector@2.5.0 --cli --config mcp-inspector.json --server evm-stdio --method tools/list --strict",
     "typecheck": "tsc --noEmit",
     "test:mcp": "bun test test",
     "check": "bun run typecheck && bun run build && bun run build:http && bun run test:mcp"

src/core/services/transfer.ts

@@ -1,5 +1,4 @@
 import { 
-  parseEther,
   parseUnits,
   type Address, 
   type Hash, 
@@ -47,6 +46,45 @@ const erc20TransferAbi = [
   }
 ] as const;
 
+/** Parse a non-negative amount without rounding away fractional base units. */
+export function parseExactAmount(amount: string, decimals: number): bigint {
+  if (!/^\d+(\.\d+)?$/.test(amount)) {
+    throw new Error('Amount must be a non-negative decimal string');
+  }
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 255) {
+    throw new Error('Invalid token decimals');
+  }
+  const fraction = (amount.split('.')[1] ?? '').replace(/0+$/, '');
+  if (fraction.length > decimals) {
+    throw new Error(`Amount exceeds ${decimals} decimal places; rounding is not allowed`);
+  }
+  const raw = parseUnits(amount, decimals);
+  if (raw >= 2n ** 256n) {
+    throw new Error('Amount exceeds uint256');
+  }
+  return raw;
+}
+
+export type TokenAmount = {
+  raw: bigint;
+  formatted: string;
+  decimals: number;
+};
+
+/** Resolve token precision before confirmation and retain the exact execution amount. */
+export async function prepareERC20Amount(
+  tokenAddress: Address,
+  amount: string,
+  network = 'ethereum'
+): Promise<TokenAmount> {
+  const decimals = await getPublicClient(network).readContract({
+    address: tokenAddress,
+    abi: erc20TransferAbi,
+    functionName: 'decimals'
+  });
+  return { raw: parseExactAmount(amount, decimals), formatted: amount, decimals };
+}
+
 /**
  * Transfer a chain's native token to an address
  * @param privateKey Sender's private key
@@ -70,7 +108,7 @@ export async function transferETH(
     : privateKey as Hex;
 
   const client = getWalletClient(formattedKey, network);
-  const amountWei = parseEther(amount);
+  const amountWei = parseExactAmount(amount, 18);
 
   return client.sendTransaction({
     to: toAddress,
@@ -84,15 +122,15 @@ export async function transferETH(
  * Transfer ERC20 tokens to an address
  * @param tokenAddressOrEns Token contract address or ENS name
  * @param toAddressOrEns Recipient address or ENS name
- * @param amount Amount to send (in token units)
+ * @param amount Exact token amount prepared before confirmation
  * @param privateKey Sender's private key
  * @param network Network name or chain ID
  * @returns Transaction details
  */
 export async function transferERC20(
   tokenAddressOrEns: string,
   toAddressOrEns: string,
-  amount: string,
+  amount: TokenAmount,
   privateKey: string | `0x${string}`,
   network: string = 'ethereum'
 ): Promise<{
@@ -123,12 +161,12 @@ export async function transferERC20(
     client: publicClient,
   });
 
-  // Get token decimals and symbol
-  const decimals = await contract.read.decimals();
+  // Preserve the precision and base units that were confirmed.
+  const decimals = amount.decimals;
   const symbol = await contract.read.symbol();
 
-  // Parse the amount with the correct number of decimals
-  const rawAmount = parseUnits(amount, decimals);
+  // Use the exact base units prepared before confirmation.
+  const rawAmount = amount.raw;
 
   // Create wallet client for sending the transaction
   const walletClient = getWalletClient(formattedKey, network);
@@ -147,7 +185,7 @@ export async function transferERC20(
     txHash: hash,
     amount: {
       raw: rawAmount,
-      formatted: amount
+      formatted: amount.formatted
     },
     token: {
       symbol,
@@ -160,15 +198,15 @@ export async function transferERC20(
  * Approve ERC20 token spending
  * @param tokenAddressOrEns Token contract address or ENS name
  * @param spenderAddressOrEns Spender address or ENS name
- * @param amount Amount to approve (in token units)
+ * @param amount Exact token amount prepared before confirmation
  * @param privateKey Owner's private key
  * @param network Network name or chain ID
  * @returns Transaction hash
  */
 export async function approveERC20(
   tokenAddressOrEns: string,
   spenderAddressOrEns: string,
-  amount: string,
+  amount: TokenAmount,
   privateKey: string | `0x${string}`,
   network: string = 'ethereum'
 ): Promise<Hash> {
@@ -181,19 +219,8 @@ export async function approveERC20(
     ? `0x${privateKey}` as `0x${string}`
     : privateKey as `0x${string}`;
 
-  // Get token details
-  const publicClient = getPublicClient(network);
-  const contract = getContract({
-    address: tokenAddress,
-    abi: erc20TransferAbi,
-    client: publicClient,
-  });
-  
-  // Get token decimals
-  const decimals = await contract.read.decimals();
-  
-  // Parse the amount with the correct number of decimals
-  const rawAmount = parseUnits(amount, decimals);
+  // Use the base units bound to the accepted confirmation, without re-reading decimals.
+  const rawAmount = amount.raw;
 
   // Create wallet client for sending the transaction
   const walletClient = getWalletClient(formattedKey, network);

src/core/tools.ts

@@ -46,7 +46,11 @@ const supportedNetworksOutputSchema = z.object({
 const gasPriceOutputSchema = z.object({
   network: z.string(),
   gasPricePerGas: z.string(),
-  priorityFeePerGas: z.string().nullable(),
+  // Branch descriptions preserve anyOf instead of Zod's compact type array.
+  priorityFeePerGas: z.union([
+    z.string().describe("Estimated priority fee in wei."),
+    z.null().describe("The network does not provide a priority fee estimate.")
+  ]),
   currency: z.literal("wei")
 });
 
@@ -1105,6 +1109,7 @@ export function registerEVMTools(server: McpServer) {
           };
         }
 
+        const valueWei = value === undefined ? undefined : services.parseExactAmount(value, 18);
         const functionSignature = `${functionAbi.name}(${
           (functionAbi.inputs ?? [])
             .map((input: { type?: unknown }) => String(input.type ?? "unknown"))
@@ -1118,6 +1123,7 @@ export function registerEVMTools(server: McpServer) {
             functionName,
             args,
             value: value ?? null,
+            valueWei: valueWei?.toString() ?? null,
             abiJson: abiJson ?? null,
             functionAbi,
             network
@@ -1140,9 +1146,8 @@ export function registerEVMTools(server: McpServer) {
         };
 
         // Add value if provided (for payable functions)
-        if (value) {
-          const { parseEther } = await import('viem');
-          writeParams.value = parseEther(value);
+        if (valueWei !== undefined) {
+          writeParams.value = valueWei;
         }
 
         // Execute the write operation
@@ -1312,11 +1317,12 @@ export function registerEVMTools(server: McpServer) {
     },
     async ({ to, amount, network = "ethereum" }, ctx) => {
       try {
+        const amountWei = services.parseExactAmount(amount, 18);
         const resolvedRecipient = await services.resolveAddress(to, network);
         const confirmation = await requireConfirmation(
           ctx,
           "transfer_native",
-          { to, resolvedRecipient, amount, network },
+          { to, resolvedRecipient, amount, amountWei: amountWei.toString(), network },
           `Transfer ${amount} native tokens to ${to} (${resolvedRecipient}) on ${network}?`
         );
         if (confirmation) {
@@ -1368,6 +1374,7 @@ export function registerEVMTools(server: McpServer) {
           services.resolveAddress(tokenAddress, network),
           services.resolveAddress(to, network)
         ]);
+        const tokenAmount = await services.prepareERC20Amount(resolvedTokenAddress, amount, network);
         const confirmation = await requireConfirmation(
           ctx,
           "transfer_erc20",
@@ -1377,9 +1384,11 @@ export function registerEVMTools(server: McpServer) {
             to,
             resolvedRecipient,
             amount,
+            rawAmount: tokenAmount.raw.toString(),
+            decimals: tokenAmount.decimals,
             network
           },
-          `Transfer ${amount} of token ${tokenAddress} (${resolvedTokenAddress}) to ${to} (${resolvedRecipient}) on ${network}?`
+          `Transfer ${amount} of token ${tokenAddress} (${resolvedTokenAddress}) to ${to} (${resolvedRecipient}) on ${network} (${tokenAmount.raw} base units at ${tokenAmount.decimals} decimals)?`
         );
         if (confirmation) {
           return confirmation;
@@ -1390,7 +1399,7 @@ export function registerEVMTools(server: McpServer) {
         const result = await services.transferERC20(
           resolvedTokenAddress,
           resolvedRecipient,
-          amount,
+          tokenAmount,
           privateKey,
           network
         );
@@ -1439,6 +1448,7 @@ export function registerEVMTools(server: McpServer) {
           services.resolveAddress(tokenAddress, network),
           services.resolveAddress(spenderAddress, network)
         ]);
+        const tokenAmount = await services.prepareERC20Amount(resolvedTokenAddress, amount, network);
         const confirmation = await requireConfirmation(
           ctx,
           "approve_token_spending",
@@ -1448,9 +1458,11 @@ export function registerEVMTools(server: McpServer) {
             spenderAddress,
             resolvedSpenderAddress,
             amount,
+            rawAmount: tokenAmount.raw.toString(),
+            decimals: tokenAmount.decimals,
             network
           },
-          `Approve ${spenderAddress} (${resolvedSpenderAddress}) to spend ${amount} of token ${tokenAddress} (${resolvedTokenAddress}) on ${network}?`
+          `Approve ${spenderAddress} (${resolvedSpenderAddress}) to spend ${amount} of token ${tokenAddress} (${resolvedTokenAddress}) on ${network} (${tokenAmount.raw} base units at ${tokenAmount.decimals} decimals)?`
         );
         if (confirmation) {
           return confirmation;
@@ -1461,7 +1473,7 @@ export function registerEVMTools(server: McpServer) {
         const txHash = await services.approveERC20(
           resolvedTokenAddress,
           resolvedSpenderAddress,
-          amount,
+          tokenAmount,
           privateKey,
           network
         );

src/server/http-app.ts

@@ -60,6 +60,47 @@ export function createHttpApp(options: HttpAppOptions): HttpApp {
     }
   });
 
+  // Browser preflights do not carry bearer tokens. Validate their host/origin
+  // before answering, and retain CORS headers on OAuth challenges and metadata.
+  app.use((req: Request, res: Response, next: NextFunction) => {
+    if (!validateHost(req, res) || !validateOrigin(req, res)) {
+      return;
+    }
+    res.vary("Origin");
+    const origin = req.get("Origin");
+    if (!origin) {
+      next();
+      return;
+    }
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Access-Control-Expose-Headers", "WWW-Authenticate, Retry-After, MCP-Protocol-Version");
+    if (req.method !== "OPTIONS") {
+      next();
+      return;
+    }
+
+    res.vary("Access-Control-Request-Method");
+    res.vary("Access-Control-Request-Headers");
+    const method = req.get("Access-Control-Request-Method");
+    const headers = (req.get("Access-Control-Request-Headers") ?? "")
+      .split(",").map(header => header.trim().toLowerCase()).filter(Boolean);
+    const allowedHeaders = new Set([
+      "accept", "content-type", "authorization", "mcp-protocol-version", "mcp-method", "mcp-name"
+    ]);
+    if (
+      !method || !["GET", "POST"].includes(method)
+      || headers.some(header => !allowedHeaders.has(header) && !/^mcp-param-[a-z0-9-]+$/.test(header))
+    ) {
+      res.status(403).end();
+      return;
+    }
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST");
+    if (headers.length) {
+      res.setHeader("Access-Control-Allow-Headers", headers.join(", "));
+    }
+    res.status(204).end();
+  });
+
   if (oauthConfiguration) {
     app.use(mcpAuthMetadataRouter({
       oauthMetadata: oauthConfiguration.oauthMetadata,
@@ -74,10 +115,6 @@ export function createHttpApp(options: HttpAppOptions): HttpApp {
     res: Response,
     next: NextFunction
   ) => {
-    if (!validateHost(req, res) || !validateOrigin(req, res)) {
-      return;
-    }
-
     if (req.method === "POST" && !isJsonContentType(req.get("Content-Type") ?? null)) {
       res.status(415).json({
         jsonrpc: "2.0",