# ZEAM Prism MCP > Pay-per-millisecond Ethereum and Base RPC over MCP. Bring a wallet: no account, no API key, no gas, no human. Wallet-paid Ethereum and Base RPC over MCP. No account, no API key, no human: an agent pays for time on the line over x402 with the wallet it already carries — a millisecond meter, not a per-call charge. Verification and settlement run in-process against our own nodes; no third-party facilitator sits in the payment path. ## Looking is free Discovery and tools/list cost nothing and need no handshake -- the transport is stateless, so there is nothing to establish before you look. Calling any tool with no payment returns the full terms as machine-readable x402 requirements. You can price us out before spending anything. And you can TEST us before spending anything: the `sample` tool is free and takes no wallet -- eth_chainId, eth_blockNumber, eth_gasPrice, net_version on eth or base, 6 per hour, through the same shelf and the same node a paid call uses. Check the answer against any other source. We would rather you verified than believed us. ## Paying - Scheme: `batch-settlement` over x402 -- the only scheme accepted. - Network: eip155:8453 (Base mainnet). - Assets accepted -- pay in whichever of these you already hold: - USDC (6 dp) 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 — fund by eip3009 or permit2; per-request ceiling $0.000250 - USDT (6 dp) 0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2 — fund by permit2; per-request ceiling $0.000250 (no EIP-3009; Permit2 only) - DAI (18 dp) 0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb — fund by permit2; per-request ceiling $0.000250 (no EIP-3009; Permit2 only) - EURC (6 dp) 0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42 — fund by eip3009 or permit2 @ $1.15086/token, 30-min TWAP from our own node; per-request ceiling $0.000250 - WETH (18 dp) 0x4200000000000000000000000000000000000006 — fund by permit2 @ $1884.54/token, 30-min TWAP from our own node; per-request ceiling $0.000250 (no EIP-3009; Permit2 only) - cbBTC (8 dp) 0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf — fund by permit2 @ $63375.9/token, 30-min TWAP from our own node; per-request ceiling $0.000634 (no EIP-3009; Permit2 only) - Pay to: 0x0Cec1E92fa2b92a93194D40C1D38E989E3C0597c. - Most one request can cost: $0.000250 -- the 250ms gap cap at the metered rate -- EXCEPT where one base unit of your asset is worth more than that, in which case the quote is one unit. cbBTC is the only asset here where that bites: 8 decimals at ~$64,000 makes its smallest unit larger than the whole cap. You are not billed that much. The meter accrues fractional units and carries the remainder between requests, so it bills a whole unit only once one has genuinely been earned -- the ceiling is coarse, the charging is not. That is our claim about our own code, and you cannot see it from outside, so here is how to check it: pay in cbBTC, measure the gaps between your own requests, and compare your cumulative charge against your measured time. Per-request rounding would bill one unit EVERY call; carrying bills roughly one unit per 640ms of line. Twelve calls should cost about two units, not twelve. Each asset states its own ceiling below. A session is as long as your deposit allows; your client tops it up when needed. Payment travels in the tool call's _meta, NOT an HTTP header. A client that sets a header will loop on 402 forever -- this is the single most expensive wrong assumption to make about MCP payments. With the TypeScript SDK: wrap the client in wrapMCPClientWithPayment(client, payments, { autoPayment: true }) and connect THROUGH the wrapper, not around it. To pay in something other than the first asset listed, give your client a requirement selector. The default one takes accepts[0], so an agent holding only DAI will otherwise watch its library reach for USDC it does not have -- we list six assets, and picking among them is the one part we cannot do for you. KEEP YOUR CHANNEL STATE. This is the sharpest edge here, and it costs money. A client that reconnects to an EXISTING channel with empty local storage pays a fresh deposit it did not need. Whether it can then USE that channel comes down to one argument in your setup: recovery from a cumulative_amount_mismatch reads the channel on chain, so it runs only if your signer can read. Give toClientEvmSigner a public client and the client heals itself on the very next call. Give it none and every later call fails with cumulative_amount_mismatch, forever. We measured it both ways against this server: with reads, recovered on call 1; without, three more calls, all refused. If you have no chain reads at all, do not reconnect blind -- pass a different `salt` and open a NEW channel, which costs one fresh deposit and always works. Fund the channel once, by EIP-3009 or Permit2 -- whichever your token and wallet support. The deposit is COLLATERAL, not a payment: it bounds how long the line can stay open. Vouchers after it cost nothing on chain, one claim settles at close, and the unused remainder is refunded. You pay no gas at any point; we submit. ## How to pay, concretely Do NOT hand-roll the EIP-3009 or Permit2 signature. batch-settlement is not stock x402: the voucher is bound to the channel, and receiverAuthorizer and withdrawDelay from the 402 are consumed by the client scheme, not signed by you. Register the scheme and it builds the whole thing. npm i @x402/core @x402/evm @x402/mcp @modelcontextprotocol/sdk viem import { Client } from '@modelcontextprotocol/sdk/client/index.js' import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js' import { wrapMCPClientWithPayment, x402Client } from '@x402/mcp' import { BatchSettlementEvmScheme } from '@x402/evm/batch-settlement/client' import { FileClientChannelStorage } from '@x402/evm/batch-settlement/client/file-storage' import { toClientEvmSigner } from '@x402/evm' import { privateKeyToAccount } from 'viem/accounts' const account = privateKeyToAccount(KEY) // pick the asset you actually hold; the default selector takes accepts[0] const payments = new x402Client((_v, accepts) => accepts.find(a => a.asset.toLowerCase() === TOKEN.toLowerCase()) ?? accepts[0]) .register('eip155:8453', new BatchSettlementEvmScheme( toClientEvmSigner(account), // no public client -- paying needs no reads { storage: new FileClientChannelStorage({ directory: "./channels" }) })) // If you might ever lose ./channels, pass a public client as the SECOND // argument -- toClientEvmSigner(account, publicClient) -- and a reconnect // with empty storage repairs itself. https://mcp.zeamprism.com/bootstrap serves exactly those // reads, free. Without it, reconnect with a fresh salt instead. const paid = wrapMCPClientWithPayment( new Client({ name: 'your-agent', version: '1' }), payments, { autoPayment: true }) await paid.connect(new StreamableHTTPClientTransport(new URL(MCP_URL))) const out = await paid.callTool('rpc', { chain: 'base', method: 'eth_blockNumber', params: [] }) Call tools POSITIONALLY -- callTool(name, args) -- as above. The stock MCP SDK shape callTool({ name, arguments }) throws "expected string, received object at params.name", which reads like our schema is broken when it is the payment wrapper having its own signature. Connect THROUGH the wrapper, not around it. The scheme carries its own hooks; registering it registers them. Nothing else is required -- no account, no key of ours, no allowlist. You do not need a Base RPC of your own, and you do not need one to pay at all. Hand toClientEvmSigner no public client and set no rpcUrl: the client then opens a channel and pays without ever reading the chain. An outside agent verified this on a wallet whose nonce was still 0 -- it had signed, and never sent a transaction. If you DO want chain reads -- to verify us, or to recover a channel whose local state you lost -- https://mcp.zeamprism.com/bootstrap serves them free, scoped to the settlement contract, its collectors and the assets we quote. You should not need it to buy. Before you decrypt a key: the `sample` tool needs no wallet at all. Prove the endpoint is real and that your client speaks to it, and only then reach for funds. A key on disk before a verified recipe is the wrong order. ## Price 1 micro-USD per 1ms of open line -- the gap since YOUR previous request, capped at 250ms. An idle pause can never cost more than that, whatever you were doing in it. Everything behind the door is included. There is no per-call charge and no price list; the tool list is what you get access to, not a menu with prices. Charges are cumulative rather than per-request, so a retry is idempotent. Verification and settlement run in-process against our own nodes. No third-party facilitator sits in the payment path. ## Nodes Ethereum mainnet and Base mainnet, run by us, on our own hardware, at chain tip. Not a resold upstream: the RPC you are billed for is the RPC we operate. The namespaces are whatever those nodes serve -- see the tools below. ## Endpoints - MCP (streamable HTTP): https://mcp.zeamprism.com/mcp - Service manifest: https://mcp.zeamprism.com/services.json - Registry entry: https://mcp.zeamprism.com/server.json ## Tools - rpc -- Forward a standard JSON-RPC call to ETH or Base — the full namespace the node serves, not a fixed method list: eth_*, net_*, web3_*, txpool_*. Includes state reads, eth_call, gas estimation, filters and eth_sendRawTransaction. Trace-tier methods are rejected — use rpc_trace. - rpc_trace -- Forward a trace-tier JSON-RPC call: debug_*, trace_*, eth_getLogs, eth_getBlockReceipts. Separated because these are orders of magnitude heavier on the node. debug_* is served on both chains; trace_* on ETH only. Standard methods are rejected — use rpc.